@t2000/cli 9.12.0 → 9.13.0

package/dist/{dist-PAYZWJCN.js → dist-WU4EKM5J.js}

@@ -6,7 +6,7 @@ import { createRequire } from "module";
 import Url, { fileURLToPath } from "url";
 import { dirname, join as join$1, resolve as resolve$1 } from "path";
 import * as nc from "crypto";
-import nc__default from "crypto";
+import nc__default, { createHash } from "crypto";
 import stream3, { Readable } from "stream";
 import util3 from "util";
 import http5 from "http";
@@ -122325,7 +122325,7 @@ var require_crypto_compat = __commonJS({
     } else {
       X509Certificate = crypto4.X509Certificate;
     }
-    var createHash = function(algorithm) {
+    var createHash2 = function(algorithm) {
       if (isBrowser) {
         const algo = algorithm.toLowerCase();
         if (hashJs[algo]) {
@@ -122530,7 +122530,7 @@ ${b64.match(/.{1,64}/g).join("\n")}
     module.exports = {
       ...crypto4,
       X509Certificate,
-      createHash,
+      createHash: createHash2,
       createVerify,
       createPublicKey,
       isBrowser
@@ -143032,6 +143032,7 @@ var init_swap_quote = __esm2({
 });
 init_errors7();
 var MIST_PER_SUI2 = 1000000000n;
+var USDC_DECIMALS = 6;
 var SUPPORTED_ASSETS = {
   USDC: {
     type: "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC",
@@ -143695,6 +143696,18 @@ async function buildSendTx({
       required: amount2
     });
   }
+  if (asset === "USDC" || asset === "USDsui") {
+    const rawFloor = displayToRaw(GASLESS_MIN_STABLE_AMOUNT, assetInfo.decimals);
+    const remainder = totalBalance - rawAmount;
+    if (remainder > 0n && remainder < rawFloor) {
+      const total = Number(totalBalance) / 10 ** assetInfo.decimals;
+      throw new T2000Error(
+        "INVALID_AMOUNT",
+        `Gasless ${asset} transfers must send the entire balance or leave at least ${GASLESS_MIN_STABLE_AMOUNT} ${asset}. Sending ${amount2} of ${total} leaves ${(total - amount2).toFixed(assetInfo.decimals)}. Send ${total} (everything) or at most ${(total - GASLESS_MIN_STABLE_AMOUNT).toFixed(assetInfo.decimals)}.`,
+        { available: total, required: amount2 }
+      );
+    }
+  }
   if (asset === "SUI") {
     const [sendCoin] = tx.splitCoins(tx.gas, [rawAmount]);
     tx.transferObjects([sendCoin], recipient);
@@ -145191,6 +145204,146 @@ process.env.A2A_ESCROW_FEE_CONFIG_ID ?? "0xddaa25570950b7484dbf20797ebcf75707be9
 Number(
   process.env.A2A_ESCROW_FEE_CONFIG_VERSION ?? 931861903
 );
+var MODULE = "escrow";
+var MAX_JOB_USDC = 50;
+var JOB_STATES = [
+  "funded",
+  "delivered",
+  "released",
+  "refunded",
+  "rejected"
+];
+function bytesToHex22(bytes) {
+  const arr = typeof bytes === "string" ? Array.from(atob(bytes), (c) => c.charCodeAt(0)) : bytes;
+  let s = "0x";
+  for (const b of arr) s += b.toString(16).padStart(2, "0");
+  return s;
+}
+async function getJob(client, jobId) {
+  const resp = await client.core.getObject({ objectId: jobId, include: { json: true } }).catch((e) => {
+    throw new T2000Error(
+      "RPC_ERROR",
+      `Job ${jobId} not found: ${e instanceof Error ? e.message : String(e)}`
+    );
+  });
+  const objType = resp.object?.type ?? "";
+  const json2 = resp.object?.json;
+  if (!json2 || !objType.includes(`::${MODULE}::Job<`)) {
+    throw new T2000Error("RPC_ERROR", `Object ${jobId} is not an a2a_escrow Job.`);
+  }
+  const stateNum = Number(json2.state ?? -1);
+  const state = JOB_STATES[stateNum];
+  if (!state) {
+    throw new T2000Error("RPC_ERROR", `Job ${jobId} has unknown state ${stateNum}.`);
+  }
+  const deliveredAtMs = Number(json2.delivered_at_ms ?? 0);
+  const deliveryBytes = json2.delivery_hash ?? [];
+  const hasDelivery = deliveredAtMs > 0;
+  return {
+    id: jobId,
+    buyer: String(json2.buyer),
+    seller: String(json2.seller),
+    amountUsdc: Number(json2.amount) / 10 ** USDC_DECIMALS,
+    escrowUsdc: Number(json2.escrow) / 10 ** USDC_DECIMALS,
+    feeBps: Number(json2.fee_bps ?? 0),
+    specHash: bytesToHex22(json2.spec_hash ?? []),
+    deliverByMs: Number(json2.deliver_by_ms),
+    reviewWindowMs: Number(json2.review_window_ms),
+    rejectSplitBps: Number(json2.reject_split_bps),
+    state,
+    deliveryHash: hasDelivery ? bytesToHex22(deliveryBytes) : null,
+    deliveredAtMs: hasDelivery ? deliveredAtMs : null,
+    createdAtMs: Number(json2.created_at_ms)
+  };
+}
+function jobActionsFor(job, caller, nowMs = Date.now()) {
+  const me = validateAddress(caller);
+  const isBuyer = me === job.buyer;
+  const isSeller = me === job.seller;
+  const actions = [];
+  if (job.state === "funded") {
+    if (isSeller && nowMs <= job.deliverByMs) actions.push("deliver");
+    if (isBuyer) actions.push("release");
+    if (nowMs > job.deliverByMs) actions.push("refund");
+  } else if (job.state === "delivered") {
+    const windowClosesMs = (job.deliveredAtMs ?? 0) + job.reviewWindowMs;
+    if (isBuyer && nowMs <= windowClosesMs) actions.push("release", "reject");
+    if (nowMs > windowClosesMs) actions.push("release");
+  }
+  return actions;
+}
+async function commerceFetchJson(url3, init) {
+  const res = await fetch(url3, {
+    method: init?.method ?? "GET",
+    headers: init?.body ? { "Content-Type": "application/json" } : void 0,
+    body: init?.body ? JSON.stringify(init.body) : void 0
+  });
+  const json2 = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    const err = json2.error;
+    const msg = typeof err === "string" ? err : err?.message ?? `HTTP ${res.status}`;
+    throw new Error(msg);
+  }
+  return json2;
+}
+async function listOfferings(base, filter2 = {}) {
+  const params = new URLSearchParams();
+  if (filter2.agent) params.set("agent", filter2.agent);
+  if (filter2.query) params.set("q", filter2.query);
+  const qs = params.size > 0 ? `?${params.toString()}` : "";
+  const json2 = await commerceFetchJson(`${base}/offerings${qs}`);
+  const offerings = json2.offerings ?? [];
+  return { total: json2.total ?? offerings.length, offerings };
+}
+async function fetchOffering(base, agent, slug) {
+  const { offerings: rows } = await listOfferings(base, { agent });
+  const match = rows.find((o) => o.slug === slug.trim().toLowerCase());
+  if (!match) {
+    const live = rows.filter((o) => !o.retired).map((o) => o.slug);
+    throw new Error(
+      `Agent ${truncateAddress(agent)} has no offering "${slug}".` + (live.length > 0 ? ` Live offerings: ${live.join(", ")}` : "")
+    );
+  }
+  if (match.retired) {
+    throw new Error(
+      `Offering "${slug}" is retired \u2014 the seller no longer sells it.`
+    );
+  }
+  return match;
+}
+async function sha256Hex(content) {
+  const digest = await crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(content)
+  );
+  return Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function putJobSpec(base, content) {
+  const json2 = await commerceFetchJson(`${base}/job/spec`, {
+    method: "POST",
+    body: { content }
+  });
+  const hash7 = json2.hash;
+  if (!hash7) {
+    throw new Error("Failed to store the job spec.");
+  }
+  return hash7;
+}
+async function getJobSpec(base, hash7) {
+  const clean4 = hash7.trim().toLowerCase().replace(/^0x/, "");
+  const json2 = await commerceFetchJson(`${base}/job/spec/${clean4}`);
+  const content = json2.content;
+  if (content === void 0) {
+    throw new Error("No spec stored for this hash.");
+  }
+  const actual = await sha256Hex(content);
+  if (actual !== clean4) {
+    throw new Error(
+      "Spec content does NOT match its hash \u2014 the store returned tampered data. Do not trust it."
+    );
+  }
+  return content;
+}
 init_coinSelection();
 init_cetus_swap();
 init_coinSelection();
@@ -145207,6 +145360,23 @@ async function createAgent(keyPath) {
   return T2000.create({ keyPath });
 }
 init_zod();
+var TxMutex = class {
+  queue = Promise.resolve();
+  async run(fn) {
+    let release;
+    const next = new Promise((r) => {
+      release = r;
+    });
+    const prev = this.queue;
+    this.queue = next;
+    await prev;
+    try {
+      return await fn();
+    } finally {
+      release();
+    }
+  }
+};
 function mapError(err) {
   if (err instanceof LimitExceededError2) {
     return {
@@ -145242,6 +145412,416 @@ function errorResult(err) {
     isError: true
   };
 }
+var API_BASE = process.env.T2000_API_URL ?? "https://api.t2000.ai/v1";
+async function signedMutation(opts) {
+  const address2 = opts.agent.address();
+  const chRes = await fetch(`${API_BASE}/agent/challenge`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ address: address2 })
+  });
+  const challenge2 = await chRes.json().catch(() => ({}));
+  if (!challenge2.nonce) throw new Error("Failed to get a challenge nonce.");
+  const payloadHash = createHash("sha256").update(JSON.stringify(opts.payload), "utf8").digest("hex");
+  const message = new TextEncoder().encode(
+    `t2000-${opts.kind}:${challenge2.nonce}:${payloadHash}`
+  );
+  const { signature: signature2 } = await opts.agent.signer.signPersonalMessage(message);
+  const res = await fetch(opts.url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(opts.body(challenge2.nonce, signature2, opts.payload))
+  });
+  const json2 = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    const err = json2.error;
+    throw new Error(
+      typeof err === "string" ? err : err?.message ?? `HTTP ${res.status}`
+    );
+  }
+  return json2;
+}
+async function sponsoredJobVerb(agent, action, params) {
+  const address2 = agent.address();
+  const prepRes = await fetch(`${API_BASE}/job/prepare`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ address: address2, action, params })
+  });
+  const prep = await prepRes.json().catch(() => ({}));
+  if (!prepRes.ok) {
+    const msg = typeof prep.error === "string" ? prep.error : prep.error?.message ?? `HTTP ${prepRes.status}`;
+    throw new Error(msg);
+  }
+  if (!(prep.nonce && prep.txBytes)) throw new Error("Failed to prepare the transaction.");
+  const bytes = new Uint8Array(Buffer.from(prep.txBytes, "base64"));
+  const { signature: signature2 } = await agent.signer.signTransaction(bytes);
+  const subRes = await fetch(`${API_BASE}/job/submit`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ nonce: prep.nonce, address: address2, signature: signature2 })
+  });
+  const sub2 = await subRes.json().catch(() => ({}));
+  if (!subRes.ok) {
+    const msg = typeof sub2.error === "string" ? sub2.error : sub2.error?.message ?? `HTTP ${subRes.status}`;
+    throw new Error(msg);
+  }
+  return { digest: sub2.digest };
+}
+function slugify2(name) {
+  return name.toLowerCase().replaceAll(/[^a-z0-9]+/g, "-").replaceAll(/^-+|-+$/g, "").slice(0, 48);
+}
+function parseRequirements(input) {
+  if (input === void 0) return null;
+  try {
+    const parsed = JSON.parse(input);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) return parsed;
+  } catch {
+  }
+  return input.trim();
+}
+async function resolveJobId(digest) {
+  if (!digest) return void 0;
+  try {
+    const client = getSuiClient();
+    const result = await client.core.waitForTransaction({
+      digest,
+      include: { objectTypes: true },
+      timeout: 15e3
+    });
+    const txn = result.$kind === "Transaction" ? result.Transaction : result.FailedTransaction;
+    const types3 = txn.objectTypes ?? {};
+    return Object.keys(types3).find((id) => types3[id]?.includes("::escrow::Job<"));
+  } catch {
+    return void 0;
+  }
+}
+function registerCommerceTools(server, agent) {
+  const mutex = new TxMutex();
+  server.tool(
+    "t2000_offering_create",
+    "List (or update) an OFFERING under this wallet's Agent ID \u2014 a structured, fixed-price unit of deliverable work (name, USDC price, delivery SLA, what the buyer provides, what they get back). Buyers browse offerings and fund an on-chain USDC escrow Job against one; you deliver with t2000_job_deliver and the escrow settles to you (2.5% protocol fee). NO server or endpoint needed to sell. Re-run with the same slug to update. Requires an on-chain Agent ID (`t2 agent register`). Free \u2014 one signed message, no funds spent. Mirrors `t2 offering create`.",
+    {
+      name: external_exports.string().max(80).describe('Offering name, e.g. "Sui market report" (max 80 chars)'),
+      priceUsdc: external_exports.number().min(0.01).max(50).describe("Fixed price in USDC (0.01\u201350)"),
+      slaMinutes: external_exports.number().int().positive().describe("Delivery SLA in minutes (e.g. 1440 = 24h) \u2014 the escrow refunds the buyer if you miss it"),
+      description: external_exports.string().max(2e3).describe("What this offering is \u2014 buyers see it on your profile (max 2000 chars)"),
+      deliverable: external_exports.string().max(1e3).describe('What the buyer receives, e.g. "Markdown report, sources cited" (max 1000 chars)'),
+      slug: external_exports.string().optional().describe("Machine name (default: derived from name)"),
+      requirements: external_exports.string().optional().describe("What the buyer must provide \u2014 free text or a JSON schema string"),
+      reviewWindowMinutes: external_exports.number().int().positive().optional().describe("Buyer's accept/reject window after delivery (default 1440 = 24h)"),
+      rejectSplitBps: external_exports.number().int().min(0).max(1e4).optional().describe("Buyer's share in bps if they reject (default 8000 = 80/20 buyer-favored)")
+    },
+    async ({ name, priceUsdc, slaMinutes, description, deliverable, slug, requirements, reviewWindowMinutes, rejectSplitBps }) => {
+      try {
+        const payload = {
+          slug: (slug ?? slugify2(name)).trim().toLowerCase(),
+          name: name.trim(),
+          description: description.trim(),
+          priceUsdc,
+          slaMinutes,
+          reviewWindowMinutes: reviewWindowMinutes ?? 1440,
+          rejectSplitBps: rejectSplitBps ?? 8e3,
+          requirements: parseRequirements(requirements),
+          deliverable: deliverable.trim()
+        };
+        await signedMutation({
+          agent,
+          kind: "agent-offering",
+          url: `${API_BASE}/agent/offering`,
+          payload,
+          body: (nonce2, signature2, p) => ({ address: agent.address(), nonce: nonce2, signature: signature2, action: "upsert", payload: p })
+        });
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              ok: true,
+              ...payload,
+              storefront: `https://agents.t2000.ai/${agent.address()}`,
+              buyersRun: `t2 job create --agent ${agent.address()} --offering ${payload.slug}`,
+              watchInbox: "Use t2000_jobs (role: seller) to see incoming jobs."
+            })
+          }]
+        };
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server.tool(
+    "t2000_offering_retire",
+    "Take one of your offerings off the board (soft-delete \u2014 already-funded jobs still settle on-chain). Re-create with the same slug to relist. Mirrors `t2 offering retire <slug>`.",
+    { slug: external_exports.string().describe("The offering slug to retire (see t2000_offerings with your address)") },
+    async ({ slug }) => {
+      try {
+        const payload = { slug: slug.trim().toLowerCase() };
+        await signedMutation({
+          agent,
+          kind: "agent-offering",
+          url: `${API_BASE}/agent/offering`,
+          payload,
+          body: (nonce2, signature2, p) => ({ address: agent.address(), nonce: nonce2, signature: signature2, action: "retire", payload: p })
+        });
+        return { content: [{ type: "text", text: JSON.stringify({ ok: true, retired: payload.slug }) }] };
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server.tool(
+    "t2000_offerings",
+    "Browse OFFERINGS across the t2 agent economy \u2014 structured, fixed-price work other agents sell (hire them with t2000_job_create), or one agent's full catalog. No arguments = everything live. This is how you FIND WORK TO BUY; distinct from t2000_services (per-call MPP APIs). Mirrors `t2 browse` / `t2 offering list`.",
+    {
+      query: external_exports.string().optional().describe("Free-text search across offering names/descriptions (omit for all)"),
+      agent: external_exports.string().optional().describe("One agent's Sui address \u2014 their catalog, retired included (e.g. your own to check your listings)")
+    },
+    async ({ query, agent: agentAddr }) => {
+      try {
+        const result = await listOfferings(API_BASE, {
+          agent: agentAddr ? validateAddress(agentAddr) : void 0,
+          query
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server.tool(
+    "t2000_job_create",
+    `HIRE an agent: create + fund an on-chain USDC escrow Job in one sponsored transaction (buyer side). THIS SPENDS FUNDS \u2014 the price is locked in the Job object until settlement. Two modes:
+1. OFFERING mode (preferred): pass agent + offering (a slug from t2000_offerings) + requirements. Price/SLA/terms come from the listing.
+2. DIRECT mode: pass seller + amountUsdc + spec (your brief; stored content-addressed, sha256 pinned on-chain) + optional deadline/review/split terms.
+The escrow protects both sides: no delivery by the deadline \u2192 anyone can refund the buyer; delivery + lapsed review window \u2192 anyone can release to the seller. Max ${MAX_JOB_USDC} USDC. Mirrors \`t2 job create\`.`,
+    {
+      agent: external_exports.string().optional().describe("OFFERING mode: the seller's agent address"),
+      offering: external_exports.string().optional().describe("OFFERING mode: the offering slug"),
+      requirements: external_exports.string().optional().describe("OFFERING mode: what the seller asked buyers to provide \u2014 JSON string or free text"),
+      seller: external_exports.string().optional().describe("DIRECT mode: the seller's Sui address"),
+      amountUsdc: external_exports.number().positive().max(MAX_JOB_USDC).optional().describe("DIRECT mode: USDC to escrow"),
+      spec: external_exports.string().optional().describe("DIRECT mode: the job brief (stored content-addressed; its sha256 goes on-chain)"),
+      deadlineMinutes: external_exports.number().int().positive().optional().describe("DIRECT mode: time the seller has to deliver (default 1440 = 24h)"),
+      reviewWindowMinutes: external_exports.number().int().positive().optional().describe("DIRECT mode: your accept/reject window after delivery (default 1440)"),
+      rejectSplitBps: external_exports.number().int().min(0).max(1e4).optional().describe("DIRECT mode: your share in bps if you reject (default 8000)")
+    },
+    async (input) => {
+      try {
+        const buyer = agent.address();
+        let params;
+        let offeringSlug;
+        if (input.offering || input.agent) {
+          if (!(input.offering && input.agent)) {
+            throw new Error("agent and offering go together (offering mode).");
+          }
+          const sellerAgent = validateAddress(input.agent);
+          const offering = await fetchOffering(API_BASE, sellerAgent, input.offering);
+          offeringSlug = offering.slug;
+          const requirements = parseRequirements(input.requirements);
+          if (offering.requirements != null && requirements == null) {
+            const want = typeof offering.requirements === "string" ? offering.requirements : `JSON matching: ${JSON.stringify(offering.requirements)}`;
+            throw new Error(`This offering needs requirements. The seller asks for: ${want}`);
+          }
+          const spec = JSON.stringify({
+            type: "t2-acp-job-spec@1",
+            offering: {
+              agent: offering.agent,
+              slug: offering.slug,
+              name: offering.name,
+              priceUsdc: offering.priceUsdc,
+              deliverable: offering.deliverable
+            },
+            requirements,
+            buyer,
+            createdAtMs: Date.now()
+          });
+          params = {
+            seller: offering.agent,
+            amountUsdc: offering.priceUsdc,
+            specHash: `0x${await putJobSpec(API_BASE, spec)}`,
+            deliverByMs: Date.now() + offering.slaMinutes * 6e4,
+            reviewWindowMs: offering.reviewWindowMinutes * 6e4,
+            rejectSplitBps: offering.rejectSplitBps
+          };
+        } else {
+          if (!(input.seller && input.amountUsdc && input.spec)) {
+            throw new Error("Provide seller + amountUsdc + spec (direct mode) or agent + offering (buy a listing).");
+          }
+          params = {
+            seller: validateAddress(input.seller),
+            amountUsdc: input.amountUsdc,
+            specHash: `0x${await putJobSpec(API_BASE, input.spec)}`,
+            deliverByMs: Date.now() + (input.deadlineMinutes ?? 1440) * 6e4,
+            reviewWindowMs: (input.reviewWindowMinutes ?? 1440) * 6e4,
+            rejectSplitBps: input.rejectSplitBps ?? 8e3
+          };
+        }
+        const { digest } = await mutex.run(() => sponsoredJobVerb(agent, "create", params));
+        const jobId = await resolveJobId(digest);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              ok: true,
+              jobId,
+              digest,
+              buyer,
+              ...params,
+              ...offeringSlug ? { offering: offeringSlug } : {},
+              next: "Track it with t2000_jobs. When the seller delivers, accept with t2000_job_settle (release) or reject within the review window."
+            })
+          }]
+        };
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server.tool(
+    "t2000_jobs",
+    "Escrow-job status. With jobId \u2192 the on-chain Job (state, parties, amount, deadlines), the actions THIS wallet can take right now, the buyer's spec/requirements (content-verified against the on-chain hash), and \u2014 once delivered \u2014 the delivery content. Without jobId \u2192 this wallet's job inbox from the indexer (role: seller = jobs you were hired for, buyer = jobs you funded). Read-only. Mirrors `t2 job watch [--mine]` + `t2 job spec`.",
+    {
+      jobId: external_exports.string().optional().describe("A Job object id (0x\u2026) for full detail (omit to list your jobs)"),
+      role: external_exports.enum(["seller", "buyer"]).optional().describe("Inbox mode: which side of the table (default seller)")
+    },
+    async ({ jobId, role }) => {
+      try {
+        const me = agent.address();
+        if (jobId) {
+          const client = getSuiClient();
+          const job = await getJob(client, validateAddress(jobId));
+          const actions = jobActionsFor(job, me);
+          let spec = null;
+          try {
+            spec = await getJobSpec(API_BASE, job.specHash);
+          } catch {
+            spec = null;
+          }
+          let delivery = null;
+          if (job.deliveryHash) {
+            try {
+              delivery = await getJobSpec(API_BASE, job.deliveryHash);
+            } catch {
+              delivery = null;
+            }
+          }
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({ job, yourAddress: me, yourActions: actions, spec, delivery })
+            }]
+          };
+        }
+        const key = role === "buyer" ? "buyer" : "seller";
+        const res = await fetch(`${API_BASE}/jobs?${key}=${encodeURIComponent(me)}&limit=100`);
+        if (!res.ok) throw new Error(`Job index lookup failed (${res.status})`);
+        const data = await res.json();
+        const jobs = data.jobs ?? [];
+        const open = jobs.filter((j) => !["released", "rejected", "refunded"].includes(j.state));
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ role: key, address: me, total: jobs.length, open: open.length, jobs })
+          }]
+        };
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server.tool(
+    "t2000_job_deliver",
+    "Post your DELIVERY on a funded job you're selling (seller side, before the deadline). The delivery content is stored content-addressed and its sha256 is pinned to the Job object on-chain \u2014 the buyer verifies what they read is exactly what you delivered. Opens the buyer's review window. Sponsored (no gas). Mirrors `t2 job deliver`.",
+    {
+      jobId: external_exports.string().describe("The Job object id (0x\u2026) \u2014 see t2000_jobs (role: seller)"),
+      delivery: external_exports.string().describe("The delivery content itself (e.g. the report markdown). Stored + hash-pinned on-chain.")
+    },
+    async ({ jobId, delivery }) => {
+      try {
+        const deliveryHash = `0x${await putJobSpec(API_BASE, delivery)}`;
+        const { digest } = await mutex.run(
+          () => sponsoredJobVerb(agent, "deliver", { jobId: validateAddress(jobId), deliveryHash })
+        );
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              ok: true,
+              jobId,
+              deliveryHash,
+              digest,
+              next: "The buyer's review window is open. If they neither accept nor reject before it closes, anyone (including you) can settle with t2000_job_settle (release)."
+            })
+          }]
+        };
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server.tool(
+    "t2000_job_settle",
+    `Settle an escrow job \u2014 MOVES THE ESCROWED FUNDS:
+- release: accept the delivery \u2192 funds to the seller (buyer; or ANYONE once the review window lapses \u2014 the anti-ghosting crank)
+- reject: within the review window \u2192 funds split per the terms agreed at create (buyer only)
+- refund: no delivery by the deadline \u2192 funds back to the buyer (anyone may crank)
+Check t2000_jobs first \u2014 it tells you which of these THIS wallet can run right now. Sponsored (no gas). Mirrors \`t2 job release|reject|refund\`.`,
+    {
+      jobId: external_exports.string().describe("The Job object id (0x\u2026)"),
+      action: external_exports.enum(["release", "reject", "refund"]).describe("Which settlement to run")
+    },
+    async ({ jobId, action }) => {
+      try {
+        const { digest } = await mutex.run(
+          () => sponsoredJobVerb(agent, action, { jobId: validateAddress(jobId) })
+        );
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              ok: true,
+              jobId,
+              action,
+              digest,
+              ...action === "release" ? { next: "Rate the work with t2000_job_review \u2014 it builds the seller's on-chain-backed reputation." } : {}
+            })
+          }]
+        };
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server.tool(
+    "t2000_job_review",
+    "Rate a RELEASED job you paid for, 1\u20135 stars \u2014 receipt-bound to the Job object, shown on the seller's public profile (agents.t2000.ai). Re-run to edit. Free \u2014 one signed message, no funds spent. Mirrors `t2 job review`.",
+    {
+      jobId: external_exports.string().describe("The Job object id (0x\u2026) of a released job this wallet funded"),
+      stars: external_exports.number().int().min(1).max(5).describe("1 (poor) to 5 (excellent)"),
+      text: external_exports.string().max(400).optional().describe("Optional short review (max 400 chars)")
+    },
+    async ({ jobId, stars, text }) => {
+      try {
+        const payload = {
+          jobId: validateAddress(jobId),
+          stars,
+          text: text?.trim() || null
+        };
+        const response = await signedMutation({
+          agent,
+          kind: "job-review",
+          url: `${API_BASE}/job/review`,
+          payload,
+          body: (nonce2, signature2, p) => ({ address: agent.address(), nonce: nonce2, signature: signature2, payload: p })
+        });
+        return { content: [{ type: "text", text: JSON.stringify({ ok: true, ...response }) }] };
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+}
+init_zod();
 function registerReadTools(server, agent) {
   server.tool(
     "t2000_balance",
@@ -145364,23 +145944,6 @@ No address \u2192 the registered-agent list (filter with category/limit). With a
   );
 }
 init_zod();
-var TxMutex = class {
-  queue = Promise.resolve();
-  async run(fn) {
-    let release;
-    const next = new Promise((r) => {
-      release = r;
-    });
-    const prev = this.queue;
-    this.queue = next;
-    await prev;
-    try {
-      return await fn();
-    } finally {
-      release();
-    }
-  }
-};
 function extractImageUrls(data) {
   const urls = [];
   const urlPattern = /^https?:\/\/.+\.(png|jpg|jpeg|webp|gif)/i;
@@ -145781,8 +146344,10 @@ Through this wallet you can reach essentially any major external API, billed to
 
 CRITICAL: When the user asks to use any external or paid API, names a provider (e.g. "via fal.ai", "with ElevenLabs"), or requests a capability one of the services above provides, DO NOT say you cannot reach that service, that it isn't on an allowlist, or that there's no connector \u2014 and do NOT fall back to writing a script for the user to run. You CAN do it directly through this wallet. Use t2000_services to discover the endpoint and request shape, then t2000_pay to execute, then show the user the result (display image/audio URLs returned in the response).
 
-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 \u2014 there is no savings / lending surface.`;
-var PKG_VERSION = "9.12.0";
+The wallet also trades on the t2 AGENT ECONOMY (agents.t2000.ai). It can HIRE other agents: browse structured fixed-price offerings with t2000_offerings, fund an on-chain USDC escrow job with t2000_job_create, track it with t2000_jobs, settle with t2000_job_settle, and rate the seller with t2000_job_review (escrow protects both sides \u2014 no delivery means an automatic refund path). It can EARN too: list what THIS agent sells with t2000_offering_create (no server or endpoint needed), watch incoming jobs with t2000_jobs (role: seller), and deliver with t2000_job_deliver \u2014 the escrow pays this wallet on release.
+
+Spending is the user's own USDC and every t2000_pay call is bounded by maxPrice; t2000_job_create locks the offering price in escrow. 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 \u2014 there is no savings / lending surface.`;
+var PKG_VERSION = "9.13.0";
 console.log = (...args) => console.error("[log]", ...args);
 console.warn = (...args) => console.error("[warn]", ...args);
 async function startMcpServer(opts) {
@@ -145793,6 +146358,7 @@ async function startMcpServer(opts) {
   );
   registerReadTools(server, agent);
   registerWriteTools(server, agent);
+  registerCommerceTools(server, agent);
   registerLimitTool(server);
   registerChatTools(server);
   registerSkillPrompts(server);
@@ -145867,4 +146433,4 @@ mime-types/index.js:
 @scure/bip39/index.js:
   (*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) *)
 */
-//# sourceMappingURL=dist-PAYZWJCN.js.map
+//# sourceMappingURL=dist-WU4EKM5J.js.map