@t2000/mcp 5.1.0 → 5.2.0

package/dist/index.js

@@ -7080,7 +7080,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve3.call(this, root, ref);
+      let _sch = resolve2.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref];
         const { schemaId } = this.opts;
@@ -7107,7 +7107,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve3(root, ref) {
+    function resolve2(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -7679,7 +7679,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve3(baseURI, relativeURI, options) {
+    function resolve2(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse5(baseURI, schemelessOptions), parse5(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
@@ -7906,7 +7906,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize: normalize2,
-      resolve: resolve3,
+      resolve: resolve2,
       resolveComponent,
       equal,
       serialize,
@@ -16202,8 +16202,8 @@ function promiseWithResolvers() {
   let resolver;
   let rejecter;
   return {
-    promise: new Promise((resolve3, reject) => {
-      resolver = resolve3;
+    promise: new Promise((resolve2, reject) => {
+      resolver = resolve2;
       rejecter = reject;
     }),
     resolve: resolver,
@@ -16340,17 +16340,17 @@ var init_dataloader = __esm({
           const cachedPromise = cacheMap.get(cacheKey);
           if (cachedPromise) {
             const cacheHits = batch.cacheHits || (batch.cacheHits = []);
-            return new Promise((resolve3) => {
+            return new Promise((resolve2) => {
               cacheHits.push(() => {
-                resolve3(cachedPromise);
+                resolve2(cachedPromise);
               });
             });
           }
         }
         batch.keys.push(key);
-        const promise = new Promise((resolve3, reject) => {
+        const promise = new Promise((resolve2, reject) => {
           batch.callbacks.push({
-            resolve: resolve3,
+            resolve: resolve2,
             reject
           });
         });
@@ -17933,12 +17933,12 @@ var init_queue = __esm({
     SerialQueue = class {
       #queue = [];
       async runTask(task) {
-        return new Promise((resolve3, reject) => {
+        return new Promise((resolve2, reject) => {
           this.#queue.push(() => {
             task().finally(() => {
               this.#queue.shift();
               if (this.#queue.length > 0) this.#queue[0]();
-            }).then(resolve3, reject);
+            }).then(resolve2, reject);
           });
           if (this.#queue.length === 1) this.#queue[0]();
         });
@@ -17951,18 +17951,18 @@ var init_queue = __esm({
         this.maxTasks = maxTasks;
       }
       runTask(task) {
-        return new Promise((resolve3, reject) => {
+        return new Promise((resolve2, reject) => {
           if (this.activeTasks < this.maxTasks) {
             this.activeTasks++;
             task().finally(() => {
               if (this.#queue.length > 0) this.#queue.shift()();
               else this.activeTasks--;
-            }).then(resolve3, reject);
+            }).then(resolve2, reject);
           } else this.#queue.push(() => {
             task().finally(() => {
               if (this.#queue.length > 0) this.#queue.shift()();
               else this.activeTasks--;
-            }).then(resolve3, reject);
+            }).then(resolve2, reject);
           });
         });
       }
@@ -18170,11 +18170,11 @@ var init_parallel = __esm({
         await this.#updateCache(() => this.#waitForLastDigest());
       }
       async executeTransaction(transaction, include, additionalSignatures = []) {
-        const { promise, resolve: resolve3, reject } = promiseWithResolvers();
+        const { promise, resolve: resolve2, reject } = promiseWithResolvers();
         const usedObjects = await this.#getUsedObjects(transaction);
         const execute = () => {
           this.#executeQueue.runTask(() => {
-            return this.#execute(transaction, usedObjects, include, additionalSignatures).then(resolve3, reject);
+            return this.#execute(transaction, usedObjects, include, additionalSignatures).then(resolve2, reject);
           });
         };
         const conflicts = /* @__PURE__ */ new Set();
@@ -20414,8 +20414,8 @@ var init_core = __esm({
           if (scheduleIndex < schedule.length) {
             const remaining = t0 + schedule[scheduleIndex] - Date.now();
             scheduleIndex++;
-            if (remaining > 0) await Promise.race([new Promise((resolve3) => setTimeout(resolve3, remaining)), abortPromise]);
-          } else await Promise.race([new Promise((resolve3) => setTimeout(resolve3, lastInterval)), abortPromise]);
+            if (remaining > 0) await Promise.race([new Promise((resolve2) => setTimeout(resolve2, remaining)), abortPromise]);
+          } else await Promise.race([new Promise((resolve2) => setTimeout(resolve2, lastInterval)), abortPromise]);
           abortSignal.throwIfAborted();
           try {
             return await this.getTransaction({
@@ -27947,8 +27947,8 @@ var init_deferred = __esm({
        */
       constructor(preventUnhandledRejectionWarning = true) {
         this._state = DeferredState.PENDING;
-        this._promise = new Promise((resolve3, reject) => {
-          this._resolve = resolve3;
+        this._promise = new Promise((resolve2, reject) => {
+          this._resolve = resolve2;
           this._reject = reject;
         });
         if (preventUnhandledRejectionWarning) {
@@ -28159,11 +28159,11 @@ var init_unary_call = __esm({
   "../../node_modules/.pnpm/@protobuf-ts+runtime-rpc@2.11.1/node_modules/@protobuf-ts/runtime-rpc/build/es2015/unary-call.js"() {
     __awaiter = function(thisArg, _arguments, P3, generator) {
       function adopt(value) {
-        return value instanceof P3 ? value : new P3(function(resolve3) {
-          resolve3(value);
+        return value instanceof P3 ? value : new P3(function(resolve2) {
+          resolve2(value);
         });
       }
-      return new (P3 || (P3 = Promise))(function(resolve3, reject) {
+      return new (P3 || (P3 = Promise))(function(resolve2, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -28179,7 +28179,7 @@ var init_unary_call = __esm({
           }
         }
         function step(result) {
-          result.done ? resolve3(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -28225,11 +28225,11 @@ var init_server_streaming_call = __esm({
   "../../node_modules/.pnpm/@protobuf-ts+runtime-rpc@2.11.1/node_modules/@protobuf-ts/runtime-rpc/build/es2015/server-streaming-call.js"() {
     __awaiter2 = function(thisArg, _arguments, P3, generator) {
       function adopt(value) {
-        return value instanceof P3 ? value : new P3(function(resolve3) {
-          resolve3(value);
+        return value instanceof P3 ? value : new P3(function(resolve2) {
+          resolve2(value);
         });
       }
-      return new (P3 || (P3 = Promise))(function(resolve3, reject) {
+      return new (P3 || (P3 = Promise))(function(resolve2, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -28245,7 +28245,7 @@ var init_server_streaming_call = __esm({
           }
         }
         function step(result) {
-          result.done ? resolve3(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -32716,11 +32716,11 @@ var init_grpc_web_format = __esm({
     init_goog_grpc_status_code();
     __awaiter3 = function(thisArg, _arguments, P3, generator) {
       function adopt(value) {
-        return value instanceof P3 ? value : new P3(function(resolve3) {
-          resolve3(value);
+        return value instanceof P3 ? value : new P3(function(resolve2) {
+          resolve2(value);
         });
       }
-      return new (P3 || (P3 = Promise))(function(resolve3, reject) {
+      return new (P3 || (P3 = Promise))(function(resolve2, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -32736,7 +32736,7 @@ var init_grpc_web_format = __esm({
           }
         }
         function step(result) {
-          result.done ? resolve3(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -45523,10 +45523,10 @@ var init_CanceledError = __esm({
 });
 
 // ../../node_modules/.pnpm/axios@1.15.2/node_modules/axios/lib/core/settle.js
-function settle(resolve3, reject, response) {
+function settle(resolve2, reject, response) {
   const validateStatus2 = response.config.validateStatus;
   if (!response.status || !validateStatus2 || validateStatus2(response.status)) {
-    resolve3(response);
+    resolve2(response);
   } else {
     reject(
       new AxiosError_default(
@@ -47726,7 +47726,7 @@ var init_http = __esm({
     http2Sessions = new Http2Sessions();
     isHttpAdapterSupported = typeof process !== "undefined" && utils_default.kindOf(process) === "process";
     wrapAsync = (asyncExecutor) => {
-      return new Promise((resolve3, reject) => {
+      return new Promise((resolve2, reject) => {
         let onDone;
         let isDone;
         const done = (value, isRejected) => {
@@ -47736,7 +47736,7 @@ var init_http = __esm({
         };
         const _resolve = (value) => {
           done(value);
-          resolve3(value);
+          resolve2(value);
         };
         const _reject = (reason) => {
           done(reason, true);
@@ -47783,7 +47783,7 @@ var init_http = __esm({
       }
     };
     http_default = isHttpAdapterSupported && function httpAdapter(config3) {
-      return wrapAsync(async function dispatchHttpRequest(resolve3, reject, onDone) {
+      return wrapAsync(async function dispatchHttpRequest(resolve2, reject, onDone) {
         const own2 = (key) => utils_default.hasOwnProp(config3, key) ? config3[key] : void 0;
         let data = own2("data");
         let lookup = own2("lookup");
@@ -47880,7 +47880,7 @@ var init_http = __esm({
           }
           let convertedData;
           if (method !== "GET") {
-            return settle(resolve3, reject, {
+            return settle(resolve2, reject, {
               status: 405,
               statusText: "method not allowed",
               headers: {},
@@ -47902,7 +47902,7 @@ var init_http = __esm({
           } else if (responseType === "stream") {
             convertedData = stream3.Readable.from(convertedData);
           }
-          return settle(resolve3, reject, {
+          return settle(resolve2, reject, {
             data: convertedData,
             status: 200,
             statusText: "OK",
@@ -48186,7 +48186,7 @@ var init_http = __esm({
               });
             }
             response.data = responseStream;
-            settle(resolve3, reject, response);
+            settle(resolve2, reject, response);
           } else {
             const responseBuffer = [];
             let totalResponseBytes = 0;
@@ -48236,7 +48236,7 @@ var init_http = __esm({
               } catch (err) {
                 return reject(AxiosError_default.from(err, null, config3, response.request, response));
               }
-              settle(resolve3, reject, response);
+              settle(resolve2, reject, response);
             });
           }
           abortEmitter.once("abort", (err) => {
@@ -48610,7 +48610,7 @@ var init_xhr = __esm({
     init_resolveConfig();
     isXHRAdapterSupported = typeof XMLHttpRequest !== "undefined";
     xhr_default = isXHRAdapterSupported && function(config3) {
-      return new Promise(function dispatchXhrRequest(resolve3, reject) {
+      return new Promise(function dispatchXhrRequest(resolve2, reject) {
         const _config = resolveConfig_default(config3);
         let requestData = _config.data;
         const requestHeaders = AxiosHeaders_default.from(_config.headers).normalize();
@@ -48645,7 +48645,7 @@ var init_xhr = __esm({
           };
           settle(
             function _resolve(value) {
-              resolve3(value);
+              resolve2(value);
               done();
             },
             function _reject(err) {
@@ -49080,8 +49080,8 @@ var init_fetch = __esm({
             config3
           );
           !isStreamResponse && unsubscribe && unsubscribe();
-          return await new Promise((resolve3, reject) => {
-            settle(resolve3, reject, {
+          return await new Promise((resolve2, reject) => {
+            settle(resolve2, reject, {
               data: responseData,
               headers: AxiosHeaders_default.from(response.headers),
               status: response.status,
@@ -49552,8 +49552,8 @@ var init_CancelToken = __esm({
           throw new TypeError("executor must be a function.");
         }
         let resolvePromise;
-        this.promise = new Promise(function promiseExecutor(resolve3) {
-          resolvePromise = resolve3;
+        this.promise = new Promise(function promiseExecutor(resolve2) {
+          resolvePromise = resolve2;
         });
         const token = this;
         this.promise.then((cancel) => {
@@ -49566,9 +49566,9 @@ var init_CancelToken = __esm({
         });
         this.promise.then = (onfulfilled) => {
           let _resolve;
-          const promise = new Promise((resolve3) => {
-            token.subscribe(resolve3);
-            _resolve = resolve3;
+          const promise = new Promise((resolve2) => {
+            token.subscribe(resolve2);
+            _resolve = resolve2;
           }).then(onfulfilled);
           promise.cancel = function reject() {
             token.unsubscribe(_resolve);
@@ -50416,7 +50416,7 @@ var init_hermes_client = __esm({
           return schema.parse(data);
         } catch (error2) {
           if (retries > 0 && !(error2 instanceof Error && error2.name === "AbortError")) {
-            await new Promise((resolve3) => setTimeout(resolve3, backoff));
+            await new Promise((resolve2) => setTimeout(resolve2, backoff));
             return this.httpRequest(url2, schema, options, retries - 1, backoff * 2);
           }
           throw error2;
@@ -72037,7 +72037,7 @@ var Protocol = class {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-        await new Promise((resolve3) => setTimeout(resolve3, pollInterval));
+        await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error2) {
@@ -72054,7 +72054,7 @@ var Protocol = class {
    */
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve2, reject) => {
       const earlyReject = (error2) => {
         reject(error2);
       };
@@ -72132,7 +72132,7 @@ var Protocol = class {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve3(parseResult.data);
+            resolve2(parseResult.data);
           }
         } catch (error2) {
           reject(error2);
@@ -72393,12 +72393,12 @@ var Protocol = class {
       }
     } catch {
     }
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve2, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve3, interval);
+      const timeoutId = setTimeout(resolve2, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -73486,7 +73486,7 @@ var McpServer = class {
     let task = createTaskResult.task;
     const pollInterval = task.pollInterval ?? 5e3;
     while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
-      await new Promise((resolve3) => setTimeout(resolve3, pollInterval));
+      await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
       const updatedTask = await extra.taskStore.getTask(taskId);
       if (!updatedTask) {
         throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
@@ -74132,12 +74132,12 @@ var StdioServerTransport = class {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve3) => {
+    return new Promise((resolve2) => {
       const json = serializeMessage(message);
       if (this._stdout.write(json)) {
-        resolve3();
+        resolve2();
       } else {
-        this._stdout.once("drain", resolve3);
+        this._stdout.once("drain", resolve2);
       }
     });
   }
@@ -80044,164 +80044,194 @@ async function resolveSuinsViaRpc(rawName, ctx = {}) {
   return body.result ?? null;
 }
 init_errors3();
-var DEFAULT_SAFEGUARD_CONFIG = {
-  locked: false,
-  maxPerTx: 0,
-  maxDailySend: 0,
-  dailyUsed: 0,
-  dailyResetDate: ""
-};
-init_errors3();
-var SafeguardError = class extends T2000Error {
-  rule;
-  details;
-  constructor(rule, details, message) {
-    const msg = message ?? buildMessage(rule, details);
-    super("SAFEGUARD_BLOCKED", msg, { rule, ...details });
-    this.name = "SafeguardError";
-    this.rule = rule;
-    this.details = details;
+var DEFAULT_CONFIG_DIR = join$1(homedir(), ".t2000");
+function resolveConfigPath(configDir) {
+  return join$1(configDir ?? DEFAULT_CONFIG_DIR, "config.json");
+}
+function todayUtc() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function readLimitsFile(configDir) {
+  const path = resolveConfigPath(configDir);
+  try {
+    return sanitize(JSON.parse(readFileSync(path, "utf-8")));
+  } catch {
+    return {};
+  }
+}
+function writeLimitsFile(file, configDir) {
+  const path = resolveConfigPath(configDir);
+  let existing = {};
+  try {
+    existing = JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    existing = {};
+  }
+  for (const dead of ["maxPerTx", "maxDailySend", "dailyUsed", "dailyResetDate", "locked"]) {
+    delete existing[dead];
+  }
+  const merged = { ...existing };
+  if (file.limits && (file.limits.perTxUsd !== void 0 || file.limits.dailyUsd !== void 0)) {
+    merged.limits = file.limits;
+  } else {
+    delete merged.limits;
+  }
+  if (file.dailySpend) merged.dailySpend = file.dailySpend;
+  else delete merged.dailySpend;
+  const dir = dirname(path);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(path, JSON.stringify(merged, null, 2) + "\n", { mode: 384 });
+  return path;
+}
+function getLimits(configDir) {
+  return readLimitsFile(configDir).limits;
+}
+function hasLimits(configDir) {
+  const l2 = readLimitsFile(configDir).limits;
+  return !!l2 && (l2.perTxUsd !== void 0 || l2.dailyUsd !== void 0);
+}
+function setLimits(limits, configDir) {
+  const file = readLimitsFile(configDir);
+  const merged = { ...file.limits };
+  if (limits.perTxUsd !== void 0) merged.perTxUsd = limits.perTxUsd;
+  if (limits.dailyUsd !== void 0) merged.dailyUsd = limits.dailyUsd;
+  return writeLimitsFile({ ...file, limits: merged }, configDir);
+}
+function clearLimits(configDir) {
+  const file = readLimitsFile(configDir);
+  return writeLimitsFile({ ...file, limits: void 0 }, configDir);
+}
+function dailySpentToday(configDir) {
+  const { dailySpend } = readLimitsFile(configDir);
+  if (!dailySpend || dailySpend.date !== todayUtc()) return 0;
+  return dailySpend.usd;
+}
+function recordDailySpend(usd, configDir) {
+  if (!Number.isFinite(usd) || usd <= 0) return;
+  const file = readLimitsFile(configDir);
+  const today = todayUtc();
+  const prior = file.dailySpend && file.dailySpend.date === today ? file.dailySpend.usd : 0;
+  writeLimitsFile({ ...file, dailySpend: { date: today, usd: prior + usd } }, configDir);
+}
+function sanitize(raw) {
+  if (typeof raw !== "object" || raw === null) return {};
+  const r = raw;
+  const out = {};
+  if (typeof r.limits === "object" && r.limits !== null) {
+    const l2 = r.limits;
+    const limits = {};
+    if (typeof l2.perTxUsd === "number" && l2.perTxUsd > 0) limits.perTxUsd = l2.perTxUsd;
+    if (typeof l2.dailyUsd === "number" && l2.dailyUsd > 0) limits.dailyUsd = l2.dailyUsd;
+    else if (typeof l2.dailySendUsd === "number" && l2.dailySendUsd > 0) limits.dailyUsd = l2.dailySendUsd;
+    if (limits.perTxUsd !== void 0 || limits.dailyUsd !== void 0) out.limits = limits;
+  }
+  if (typeof r.dailySpend === "object" && r.dailySpend !== null) {
+    const d = r.dailySpend;
+    if (typeof d.date === "string" && typeof d.usd === "number" && d.usd >= 0) {
+      out.dailySpend = { date: d.date, usd: d.usd };
+    }
+  }
+  return out;
+}
+var LimitExceededError = class extends Error {
+  code = "LIMIT_EXCEEDED";
+  operation;
+  limitKind;
+  limit;
+  attempted;
+  constructor(params) {
+    const label = params.limitKind === "perTxUsd" ? "per-transaction limit" : "daily spend limit";
+    super(
+      `Exceeds ${label} ($${params.limit}). Attempted $${params.attempted.toFixed(2)}. Use --force / force:true to override.`
+    );
+    this.name = "LimitExceededError";
+    this.operation = params.operation;
+    this.limitKind = params.limitKind;
+    this.limit = params.limit;
+    this.attempted = params.attempted;
   }
   toJSON() {
     return {
-      error: "SAFEGUARD_BLOCKED",
+      error: this.code,
       message: this.message,
-      retryable: this.retryable,
-      data: { rule: this.rule, ...this.details }
+      operation: this.operation,
+      limitKind: this.limitKind,
+      limit: this.limit,
+      attempted: this.attempted
     };
   }
 };
-function buildMessage(rule, details) {
-  switch (rule) {
-    case "locked":
-      return "Agent is locked. All operations are frozen.";
-    case "maxPerTx":
-      return `Amount $${(details.attempted ?? 0).toFixed(2)} exceeds per-transaction limit ($${(details.limit ?? 0).toFixed(2)})`;
-    case "maxDailySend":
-      return `Daily send limit reached ($${(details.current ?? 0).toFixed(2)}/$${(details.limit ?? 0).toFixed(2)} used today)`;
-  }
-}
-var SafeguardEnforcer = class {
-  config;
-  configPath;
-  constructor(configDir) {
-    this.config = { ...DEFAULT_SAFEGUARD_CONFIG };
-    this.configPath = configDir ? join$1(configDir, "config.json") : null;
-  }
-  load() {
-    if (!this.configPath) return;
-    try {
-      const raw = JSON.parse(readFileSync(this.configPath, "utf-8"));
-      this.config = {
-        ...DEFAULT_SAFEGUARD_CONFIG,
-        locked: raw.locked ?? false,
-        maxPerTx: raw.maxPerTx ?? 0,
-        maxDailySend: raw.maxDailySend ?? 0,
-        dailyUsed: raw.dailyUsed ?? 0,
-        dailyResetDate: raw.dailyResetDate ?? ""
-      };
-    } catch {
-      this.config = { ...DEFAULT_SAFEGUARD_CONFIG };
-    }
-  }
-  assertNotLocked() {
-    this.load();
-    if (this.config.locked) {
-      throw new SafeguardError("locked", {});
-    }
-  }
-  check(metadata) {
-    this.load();
-    if (this.config.locked) {
-      throw new SafeguardError("locked", {});
-    }
-    const amount = metadata.amount ?? 0;
-    if (this.config.maxPerTx > 0 && amount > this.config.maxPerTx) {
-      throw new SafeguardError("maxPerTx", {
-        attempted: amount,
-        limit: this.config.maxPerTx
-      });
-    }
-    this.resetDailyIfNewDay();
-    if (this.config.maxDailySend > 0 && this.config.dailyUsed + amount > this.config.maxDailySend) {
-      throw new SafeguardError("maxDailySend", {
-        attempted: amount,
-        limit: this.config.maxDailySend,
-        current: this.config.dailyUsed
-      });
-    }
+function approxUsdValue(asset, amount) {
+  const symbol = asset.toUpperCase();
+  if (symbol === "USDC" || symbol === "USDSUI") return amount;
+  return null;
+}
+function assertLimitConfig(input) {
+  if (input.force) return;
+  if (!Number.isFinite(input.amountUsd) || input.amountUsd <= 0) return;
+  const { limits } = input;
+  if (!limits) return;
+  if (limits.perTxUsd !== void 0 && input.amountUsd > limits.perTxUsd) {
+    throw new LimitExceededError({
+      operation: input.operation,
+      limitKind: "perTxUsd",
+      limit: limits.perTxUsd,
+      attempted: input.amountUsd
+    });
   }
-  recordUsage(amount) {
-    this.resetDailyIfNewDay();
-    this.config.dailyUsed += amount;
-    this.save();
+  if (limits.dailyUsd !== void 0 && input.spentTodayUsd + input.amountUsd > limits.dailyUsd) {
+    throw new LimitExceededError({
+      operation: input.operation,
+      limitKind: "dailyUsd",
+      // The cap is total/day; report the cap (attempted is THIS write's USD).
+      limit: limits.dailyUsd,
+      attempted: input.spentTodayUsd + input.amountUsd
+    });
   }
-  lock() {
-    this.config.locked = true;
-    this.save();
+}
+var LimitEnforcer = class {
+  constructor(configDir) {
+    this.configDir = configDir;
+  }
+  /** Throws `LimitExceededError` when the write exceeds an opted-in cap. */
+  assert(input) {
+    assertLimitConfig({
+      limits: getLimits(this.configDir),
+      spentTodayUsd: dailySpentToday(this.configDir),
+      operation: input.operation,
+      amountUsd: input.amountUsd,
+      force: input.force
+    });
   }
-  unlock() {
-    this.config.locked = false;
-    this.save();
+  /** Add a settled write's USD value to today's cumulative total. */
+  record(amountUsd) {
+    recordDailySpend(amountUsd, this.configDir);
   }
-  set(key, value) {
-    if (key === "locked" && typeof value === "boolean") {
-      this.config.locked = value;
-    } else if (key === "maxPerTx" && typeof value === "number") {
-      this.config.maxPerTx = value;
-    } else if (key === "maxDailySend" && typeof value === "number") {
-      this.config.maxDailySend = value;
-    }
-    this.save();
+  getLimits() {
+    return getLimits(this.configDir);
   }
-  getConfig() {
-    this.load();
-    this.resetDailyIfNewDay();
-    return { ...this.config };
+  hasLimits() {
+    return hasLimits(this.configDir);
   }
-  isConfigured() {
-    return this.config.maxPerTx > 0 || this.config.maxDailySend > 0;
+  setLimits(limits) {
+    setLimits(limits, this.configDir);
   }
-  resetDailyIfNewDay() {
-    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    if (this.config.dailyResetDate !== today) {
-      this.config.dailyUsed = 0;
-      this.config.dailyResetDate = today;
-      this.save();
-    }
+  clearLimits() {
+    clearLimits(this.configDir);
   }
-  save() {
-    if (!this.configPath) return;
-    try {
-      let existing = {};
-      try {
-        existing = JSON.parse(readFileSync(this.configPath, "utf-8"));
-      } catch {
-      }
-      const merged = {
-        ...existing,
-        locked: this.config.locked,
-        maxPerTx: this.config.maxPerTx,
-        maxDailySend: this.config.maxDailySend,
-        dailyUsed: this.config.dailyUsed,
-        dailyResetDate: this.config.dailyResetDate
-      };
-      const dir = this.configPath.replace(/[/\\][^/\\]+$/, "");
-      if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-      }
-      writeFileSync(this.configPath, JSON.stringify(merged, null, 2) + "\n");
-    } catch {
-    }
+  dailySpentToday() {
+    return dailySpentToday(this.configDir);
   }
 };
-var DEFAULT_CONFIG_DIR = join$1(homedir(), ".t2000");
+var DEFAULT_CONFIG_DIR2 = join$1(homedir(), ".t2000");
 var T2000 = class _T2000 extends import_index2.default {
   _signer;
   _keypair;
   client;
   _address;
-  enforcer;
+  /** Unified spending-limit gate (per-tx + cumulative daily, USD). Shared by
+   *  CLI + MCP + programmatic writes — one gate, no bypass (R-0 Finding 1). */
+  limits;
   constructor(keypairOrSigner, client, configDir, isSignerMode) {
     super();
     if (isSignerMode) {
@@ -80215,8 +80245,7 @@ var T2000 = class _T2000 extends import_index2.default {
       this._address = getAddress(kp);
     }
     this.client = client;
-    this.enforcer = new SafeguardEnforcer(configDir);
-    this.enforcer.load();
+    this.limits = new LimitEnforcer(configDir);
   }
   static async create(options = {}) {
     const { keyPath, rpcUrl } = options;
@@ -80229,7 +80258,7 @@ var T2000 = class _T2000 extends import_index2.default {
       );
     }
     const keypair = await loadKey(void 0, keyPath);
-    return new _T2000(keypair, client, DEFAULT_CONFIG_DIR);
+    return new _T2000(keypair, client, DEFAULT_CONFIG_DIR2);
   }
   static fromPrivateKey(privateKey, options = {}) {
     const keypair = keypairFromPrivateKey(privateKey);
@@ -80240,7 +80269,7 @@ var T2000 = class _T2000 extends import_index2.default {
     const keypair = generateKeypair();
     await saveKey(keypair, void 0, options.keyPath);
     const client = getSuiClient();
-    const agent = new _T2000(keypair, client, DEFAULT_CONFIG_DIR);
+    const agent = new _T2000(keypair, client, DEFAULT_CONFIG_DIR2);
     const address = agent.address();
     return { agent, address };
   }
@@ -80262,11 +80291,10 @@ var T2000 = class _T2000 extends import_index2.default {
   }
   // -- MPP Payments --
   async pay(options) {
-    this.enforcer.assertNotLocked();
-    this.enforcer.check({ operation: "pay", amount: options.maxPrice ?? 1 });
+    this.limits.assert({ operation: "pay", amountUsd: options.maxPrice ?? 0, force: options.force });
     const result = await payWithMpp({ signer: this._signer, client: this.client, options });
     if (result.paid) {
-      this.enforcer.recordUsage(result.cost ?? options.maxPrice ?? 1);
+      this.limits.record(result.cost ?? options.maxPrice ?? 0);
     }
     return result;
   }
@@ -80280,7 +80308,11 @@ var T2000 = class _T2000 extends import_index2.default {
   // and the S.323 build-tracker entry.
   // -- Swap --
   async swap(params) {
-    this.enforcer.assertNotLocked();
+    this.limits.assert({
+      operation: "swap",
+      amountUsd: approxUsdValue(params.from, params.amount) ?? 0,
+      force: params.force
+    });
     const { findSwapRoute: findSwapRoute2, buildSwapTx: buildSwapTx2, resolveTokenType: resolveTokenType2 } = await Promise.resolve().then(() => (init_cetus_swap(), cetus_swap_exports));
     const fromType = resolveTokenType2(params.from);
     const toType = resolveTokenType2(params.to);
@@ -80372,6 +80404,7 @@ var T2000 = class _T2000 extends import_index2.default {
     const fromName = resolveSymbol(fromType);
     const toName = resolveSymbol(toType);
     const routeDesc = route.routerData.paths?.map((p) => p.provider).filter(Boolean).slice(0, 3).join(" + ") ?? "Cetus Aggregator";
+    this.limits.record(approxUsdValue(params.from, params.amount) ?? 0);
     return {
       success: true,
       tx: gasResult.digest,
@@ -80428,7 +80461,6 @@ var T2000 = class _T2000 extends import_index2.default {
    * the "build via gRPC, execute via JSON-RPC" hybrid).
    */
   async send(params) {
-    this.enforcer.assertNotLocked();
     const asset = params.asset;
     if (!asset) {
       throw new T2000Error(
@@ -80438,6 +80470,11 @@ var T2000 = class _T2000 extends import_index2.default {
     }
     assertAllowedAsset("send", asset);
     const sendableAsset = asset;
+    this.limits.assert({
+      operation: "send",
+      amountUsd: approxUsdValue(sendableAsset, params.amount) ?? 0,
+      force: params.force
+    });
     const resolved = await this.resolveRecipient(params.to);
     const sendAmount = params.amount;
     const sendTo = resolved.address;
@@ -80449,7 +80486,7 @@ var T2000 = class _T2000 extends import_index2.default {
       () => buildSendTx({ client: this.client, address: this._address, to: sendTo, amount: sendAmount, asset: sendableAsset }),
       { buildClient }
     );
-    this.enforcer.recordUsage(sendAmount);
+    this.limits.record(approxUsdValue(sendableAsset, sendAmount) ?? 0);
     const balance = await this.balance();
     this.emitBalanceChange(sendableAsset, sendAmount, "send", gasResult.digest);
     return {
@@ -80616,12 +80653,18 @@ init_zod();
 
 // src/errors.ts
 function mapError(err) {
-  if (err instanceof SafeguardError) {
+  if (err instanceof LimitExceededError) {
     return {
-      code: "SAFEGUARD_BLOCKED",
+      code: err.code,
+      // 'LIMIT_EXCEEDED'
       message: err.message,
       retryable: false,
-      details: { rule: err.rule, ...err.details }
+      details: {
+        operation: err.operation,
+        limitKind: err.limitKind,
+        limit: err.limit,
+        attempted: err.attempted
+      }
     };
   }
   if (err instanceof T2000Error) {
@@ -80902,25 +80945,18 @@ ${text}`;
     }
   );
 }
-function defaultConfigPath() {
-  return resolve(homedir(), ".t2000", "config.json");
-}
-async function readLimits(configPath) {
-  const path = configPath ?? defaultConfigPath();
-  try {
-    const content = await readFile(path, "utf-8");
-    const raw = JSON.parse(content);
-    if (typeof raw !== "object" || raw === null) return { configured: false, configPath: path };
-    const limits = raw.limits;
-    if (typeof limits !== "object" || limits === null) return { configured: false, configPath: path };
-    const l2 = limits;
-    const perTxUsd = typeof l2.perTxUsd === "number" && l2.perTxUsd > 0 ? l2.perTxUsd : void 0;
-    const dailySendUsd = typeof l2.dailySendUsd === "number" && l2.dailySendUsd > 0 ? l2.dailySendUsd : void 0;
-    const configured = perTxUsd !== void 0 || dailySendUsd !== void 0;
-    return { configured, perTxUsd, dailySendUsd, configPath: path };
-  } catch {
-    return { configured: false, configPath: path };
-  }
+
+// src/tools/limit.ts
+function readLimits(configDir) {
+  const limits = getLimits(configDir);
+  const perTxUsd = limits?.perTxUsd;
+  const dailyUsd = limits?.dailyUsd;
+  return {
+    configured: perTxUsd !== void 0 || dailyUsd !== void 0,
+    perTxUsd,
+    dailyUsd,
+    spentTodayUsd: dailySpentToday(configDir)
+  };
 }
 function registerLimitTool(server) {
   server.tool(
@@ -80933,7 +80969,7 @@ Use the returned values to inform the user about their own configured caps befor
     {},
     async () => {
       try {
-        const view = await readLimits();
+        const view = readLimits();
         return { content: [{ type: "text", text: JSON.stringify(view) }] };
       } catch (err) {
         return errorResult(err);
@@ -80985,7 +81021,7 @@ CRITICAL: When the user asks to use any external or paid API, names a provider (
 Spending is the user's own USDC and every t2000_pay call is bounded by maxPrice. For larger or multi-step spends, state the estimated cost first and proceed once the user is happy. Use t2000_balance to check funds. The v4 wallet is payments-only; savings / lending live on audric.ai.`;
 
 // src/index.ts
-var PKG_VERSION = "5.1.0" ;
+var PKG_VERSION = "5.2.0" ;
 console.log = (...args) => console.error("[log]", ...args);
 console.warn = (...args) => console.error("[warn]", ...args);
 async function startMcpServer(opts) {