carpool-mcp 0.1.0

package/dist/cli.js

@@ -0,0 +1,1214 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// apps/registry/src/scripts/associate-account-lib.ts
+function parseAccountId(value) {
+  const v = (value ?? "").trim();
+  if (!v) throw new InputError("HEDERA_ACCOUNT_ID is not set. Pass it as an environment variable, e.g. HEDERA_ACCOUNT_ID=0.0.12345");
+  if (!/^0\.0\.\d+$/.test(v)) {
+    throw new InputError(`HEDERA_ACCOUNT_ID must look like 0.0.12345 (got a value of length ${v.length})`);
+  }
+  return v;
+}
+function parsePrivateKey(value) {
+  let v = (value ?? "").trim();
+  if (!v) throw new InputError("HEDERA_PRIVATE_KEY is not set. Pass it as an environment variable, never as an argument.");
+  if (v.startsWith("0x") || v.startsWith("0X")) v = v.slice(2);
+  v = v.toLowerCase();
+  if (!/^[0-9a-f]+$/.test(v)) {
+    throw new InputError("HEDERA_PRIVATE_KEY is not hex. Copy the HEX encoded private key from portal.hedera.com.");
+  }
+  if (v.startsWith(ED25519_DER_PREFIX) && v.length === ED25519_DER_PREFIX.length + 64) {
+    throw ed25519Error();
+  }
+  if (v.startsWith(ECDSA_DER_PREFIX) && v.length === ECDSA_DER_PREFIX.length + 64) {
+    return { kind: "ecdsa", rawHex: v.slice(ECDSA_DER_PREFIX.length) };
+  }
+  if (v.length === 64) return { kind: "raw", rawHex: v };
+  throw new InputError(
+    `HEDERA_PRIVATE_KEY has ${v.length} hex characters; expected 64 (raw) or a DER-encoded ECDSA key.`
+  );
+}
+function checkAccountKeyType(mirrorKeyType) {
+  if (mirrorKeyType === "ECDSA_SECP256K1") return;
+  if (mirrorKeyType === "ED25519") throw ed25519Error();
+  throw new InputError(
+    `This account's key is ${mirrorKeyType ?? "unknown"}, not a single ECDSA key. Create an ECDSA testnet account at portal.hedera.com.`
+  );
+}
+function ed25519Error() {
+  return new InputError(
+    "This is an ED25519 key. Carpool needs ECDSA: the x402 Hedera signer fails on ED25519. Create an ECDSA testnet account at portal.hedera.com and use that one."
+  );
+}
+var USDC_TESTNET, ECDSA_DER_PREFIX, ED25519_DER_PREFIX, InputError;
+var init_associate_account_lib = __esm({
+  "apps/registry/src/scripts/associate-account-lib.ts"() {
+    "use strict";
+    USDC_TESTNET = "0.0.429274";
+    ECDSA_DER_PREFIX = "3030020100300706052b8104000a04220420";
+    ED25519_DER_PREFIX = "302e020100300506032b657004220420";
+    InputError = class extends Error {
+    };
+  }
+});
+
+// apps/registry/src/scripts/associate-account-run.ts
+var associate_account_run_exports = {};
+__export(associate_account_run_exports, {
+  InputError: () => InputError,
+  associateAccount: () => associateAccount
+});
+import { AccountId, Client, PrivateKey, TokenAssociateTransaction, TokenId } from "@hiero-ledger/sdk";
+async function mirrorAccount(id) {
+  const res = await fetch(`${MIRROR}/api/v1/accounts/${id}`);
+  if (res.status === 404) return null;
+  if (!res.ok) throw new Error(`mirror node answered ${res.status} for account ${id}`);
+  return await res.json();
+}
+async function isAssociated(id, token) {
+  const res = await fetch(`${MIRROR}/api/v1/accounts/${id}/tokens?token.id=${token}`);
+  if (!res.ok) throw new Error(`mirror node answered ${res.status} for ${id}'s tokens`);
+  const json = await res.json();
+  return (json.tokens ?? []).length > 0;
+}
+async function associateAccount() {
+  const id = parseAccountId(process.env.HEDERA_ACCOUNT_ID);
+  const parsed = parsePrivateKey(process.env.HEDERA_PRIVATE_KEY);
+  const token = USDC_TESTNET;
+  const account = await mirrorAccount(id);
+  if (!account) {
+    throw new InputError(`Account ${id} was not found on Hedera testnet. Check the id, and that it is a testnet account.`);
+  }
+  checkAccountKeyType(account.key?._type);
+  const key = PrivateKey.fromStringECDSA(parsed.rawHex);
+  const mirrorPub = (account.key?.key ?? "").toLowerCase();
+  if (mirrorPub && key.publicKey.toStringRaw().toLowerCase() !== mirrorPub) {
+    throw new InputError(`HEDERA_PRIVATE_KEY does not belong to ${id}. Use the private key shown for that account.`);
+  }
+  if (await isAssociated(id, token)) {
+    console.log(`${id}: already associated with USDC ${token}. Nothing to do.`);
+    return 0;
+  }
+  if ((account.balance?.balance ?? 0) <= 0) {
+    throw new InputError(`${id} has no HBAR to pay the association fee (about $0.05). Fund it from portal.hedera.com.`);
+  }
+  const client = Client.forTestnet().setOperator(AccountId.fromString(id), key);
+  try {
+    const resp = await new TokenAssociateTransaction().setAccountId(AccountId.fromString(id)).setTokenIds([TokenId.fromString(token)]).freezeWith(client).sign(key).then((tx) => tx.execute(client));
+    console.log(`transaction: ${resp.transactionId.toString()}`);
+    const rcpt = await resp.getReceipt(client);
+    console.log(`status: ${rcpt.status.toString()}`);
+  } catch (e) {
+    const msg = e.message;
+    if (msg.includes("TOKEN_ALREADY_ASSOCIATED_TO_ACCOUNT")) {
+      console.log(`${id}: already associated with USDC ${token}. Nothing to do.`);
+      return 0;
+    }
+    if (msg.includes("INSUFFICIENT_PAYER_BALANCE") || msg.includes("INSUFFICIENT_ACCOUNT_BALANCE")) {
+      throw new InputError(`${id} does not have enough HBAR for the association fee. Fund it from portal.hedera.com.`);
+    }
+    if (msg.includes("INVALID_SIGNATURE")) {
+      throw new InputError(`The network rejected the signature: HEDERA_PRIVATE_KEY is not ${id}'s key.`);
+    }
+    throw e;
+  } finally {
+    client.close();
+  }
+  for (let i = 0; i < 10; i++) {
+    if (await isAssociated(id, token)) {
+      console.log(`mirror node confirms ${id} is associated with USDC ${token}.`);
+      return 0;
+    }
+    await new Promise((r) => setTimeout(r, 2e3));
+  }
+  console.log(`receipt succeeded; the mirror node has not caught up yet. Re-run in a minute to confirm.`);
+  return 0;
+}
+var MIRROR;
+var init_associate_account_run = __esm({
+  "apps/registry/src/scripts/associate-account-run.ts"() {
+    "use strict";
+    init_associate_account_lib();
+    MIRROR = "https://testnet.mirrornode.hedera.com";
+  }
+});
+
+// apps/mcp/src/consent.ts
+var consent_exports = {};
+__export(consent_exports, {
+  ASK_REASON: () => ASK_REASON,
+  CONSENT_MODES: () => CONSENT_MODES,
+  CONSENT_MODE_ENV: () => CONSENT_MODE_ENV,
+  decideConsent: () => decideConsent,
+  hookOutput: () => hookOutput
+});
+function decideConsent(input, cfg = {}) {
+  if (input.agent_id) {
+    return {
+      decision: "deny",
+      reason: "carpool_publish is not available to subagents. Publishing is irreversible and needs a human in an interactive session; a subagent cannot be one."
+    };
+  }
+  if (input.permission_mode && NON_PROMPTING_MODES.has(input.permission_mode)) {
+    return {
+      decision: "deny",
+      reason: `carpool_publish is not available in permission mode "${input.permission_mode}", which does not prompt. Publishing cannot be auto-approved.`
+    };
+  }
+  const raw = cfg.mode?.trim();
+  if (raw === "off") {
+    return {
+      decision: "deny",
+      reason: `Publishing is turned off here (${CONSENT_MODE_ENV}=off).`
+    };
+  }
+  if (raw !== void 0 && raw !== "" && raw !== "ask") {
+    return {
+      decision: "deny",
+      reason: `${CONSENT_MODE_ENV} is set to "${raw}", which is not one of ${CONSENT_MODES.join(" | ")}. Refusing rather than guessing at an irreversible action.`
+    };
+  }
+  return { decision: "ask", reason: ASK_REASON };
+}
+function hookOutput(d) {
+  return {
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: d.decision,
+      permissionDecisionReason: d.reason
+    }
+  };
+}
+var CONSENT_MODES, CONSENT_MODE_ENV, NON_PROMPTING_MODES, ASK_REASON;
+var init_consent = __esm({
+  "apps/mcp/src/consent.ts"() {
+    "use strict";
+    CONSENT_MODES = ["ask", "off"];
+    CONSENT_MODE_ENV = "CARPOOL_PUBLISH_MODE";
+    NON_PROMPTING_MODES = /* @__PURE__ */ new Set(["bypassPermissions", "acceptEdits", "dontAsk", "auto"]);
+    ASK_REASON = "Publishing puts this research on sale. It cannot be recalled once bought \u2014 delisting stops new sales but copies already paid for stay with their buyers. Review the question, sources and stripped items before approving.";
+  }
+});
+
+// packages/hedera-x402/src/units.ts
+import { createHash } from "node:crypto";
+function sha256(input) {
+  return createHash("sha256").update(input).digest("hex");
+}
+var init_units = __esm({
+  "packages/hedera-x402/src/units.ts"() {
+  }
+});
+
+// packages/carpool-core/src/manifest.ts
+import { z } from "zod";
+function normalizeQuestion(q) {
+  const collapsed = q.toLowerCase().trim().replace(/\s+/g, " ");
+  return collapsed.replace(/[\s.,!?;:'"()]+$/g, "");
+}
+var ManifestSchema;
+var init_manifest = __esm({
+  "packages/carpool-core/src/manifest.ts"() {
+    "use strict";
+    ManifestSchema = z.object({
+      /** swarm:<sha256 hex> — see magnet.ts. Content-addressed, not question-addressed. */
+      magnet: z.string().regex(/^swarm:[0-9a-f]{64}$/, "magnet must be swarm:<64 hex>"),
+      question: z.string().min(1),
+      /** Canonicalised question: lowercase, collapsed whitespace, no trailing punctuation. */
+      questionNorm: z.string().min(1),
+      /** The event this artifact answers a question about, e.g. "ethonline-2026". */
+      scope: z.string().min(1).optional(),
+      abstract: z.string().min(1),
+      sources: z.array(
+        z.object({
+          url: z.string().url(),
+          fetchedAt: z.string().datetime({ offset: true })
+        })
+      ),
+      provenance: z.object({
+        model: z.string().min(1),
+        durationSeconds: z.number().nonnegative(),
+        inputTokens: z.number().int().nonnegative(),
+        outputTokens: z.number().int().nonnegative(),
+        estimatedCostUsd: z.number().nonnegative(),
+        toolCalls: z.number().int().nonnegative()
+      }),
+      decay: z.object({
+        /** Zero and negative half-lives are rejected here — freshness would divide by <=0. */
+        halfLifeDays: z.number().positive(),
+        producedAt: z.string().datetime({ offset: true })
+      }),
+      /** OPAQUE. Never parse as a Hedera id — see AuthorIdentity in identity.ts. */
+      author: z.string().min(1),
+      /** sha256 hex of the paid body. */
+      bodyHash: z.string().regex(/^[0-9a-f]{64}$/, "bodyHash must be sha256 hex"),
+      bodyBytes: z.number().int().nonnegative(),
+      redacted: z.boolean()
+    });
+  }
+});
+
+// packages/carpool-core/src/magnet.ts
+import { createHash as createHash2 } from "node:crypto";
+function canonicalize(value) {
+  if (Array.isArray(value)) return value.map(canonicalize);
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const key of Object.keys(value).sort()) {
+      out[key] = canonicalize(value[key]);
+    }
+    return out;
+  }
+  return value;
+}
+function canonicalHash(value) {
+  return createHash2("sha256").update(JSON.stringify(canonicalize(value))).digest("hex");
+}
+function magnetOf(m) {
+  const { magnet: _magnet, ...rest } = m;
+  return `swarm:${canonicalHash(rest)}`;
+}
+var init_magnet = __esm({
+  "packages/carpool-core/src/magnet.ts"() {
+    "use strict";
+  }
+});
+
+// packages/carpool-core/src/decay.ts
+var init_decay = __esm({
+  "packages/carpool-core/src/decay.ts"() {
+    "use strict";
+  }
+});
+
+// packages/carpool-core/src/pricing.ts
+function priceForRedoCost(estimatedCostUsd) {
+  return Math.max(
+    MIN_PRICE_MICRO_USDC,
+    Math.round(estimatedCostUsd * 1e6 * PRICE_SHARE_OF_REDO_COST)
+  );
+}
+function floorForPrice(priceMicroUsdc) {
+  return Math.max(MIN_PRICE_MICRO_USDC, Math.round(priceMicroUsdc * PRICE_FLOOR_SHARE));
+}
+function maxBuyableRedoCostUsd(capMicroUsdc2) {
+  return capMicroUsdc2 / 1e6 / PRICE_SHARE_OF_REDO_COST;
+}
+function capMicroUsdc(env = process.env) {
+  const raw = env.CARPOOL_MAX_MICRO_USDC;
+  if (raw == null || raw.trim() === "") return DEFAULT_CAP_MICRO_USDC;
+  const n = Number(raw);
+  if (!Number.isFinite(n) || n < 0) return DEFAULT_CAP_MICRO_USDC;
+  return Math.trunc(n);
+}
+var PRICE_SHARE_OF_REDO_COST, MIN_PRICE_MICRO_USDC, PRICE_FLOOR_SHARE, DEFAULT_MAX_REDO_COST_USD, DEFAULT_CAP_MICRO_USDC;
+var init_pricing = __esm({
+  "packages/carpool-core/src/pricing.ts"() {
+    "use strict";
+    PRICE_SHARE_OF_REDO_COST = 0.1;
+    MIN_PRICE_MICRO_USDC = 1e3;
+    PRICE_FLOOR_SHARE = 0.1;
+    DEFAULT_MAX_REDO_COST_USD = 5;
+    DEFAULT_CAP_MICRO_USDC = Math.round(
+      DEFAULT_MAX_REDO_COST_USD * 1e6 * PRICE_SHARE_OF_REDO_COST
+    );
+  }
+});
+
+// packages/carpool-core/src/health.ts
+var init_health = __esm({
+  "packages/carpool-core/src/health.ts"() {
+    "use strict";
+  }
+});
+
+// packages/carpool-core/src/ratings.ts
+var VERDICT_SHARE;
+var init_ratings = __esm({
+  "packages/carpool-core/src/ratings.ts"() {
+    "use strict";
+    VERDICT_SHARE = 2 / 3;
+  }
+});
+
+// packages/carpool-core/src/identity.ts
+import { PrivateKey as PrivateKey2, PublicKey } from "@hiero-ledger/sdk";
+function signManifest(privKeyHex, manifestHash) {
+  const key = PrivateKey2.fromStringECDSA(privKeyHex);
+  return Buffer.from(key.sign(Buffer.from(manifestHash, "hex"))).toString("hex");
+}
+function publicKeyHexOf(privKeyHex) {
+  return PrivateKey2.fromStringECDSA(privKeyHex).publicKey.toStringRaw();
+}
+var init_identity = __esm({
+  "packages/carpool-core/src/identity.ts"() {
+    "use strict";
+  }
+});
+
+// packages/carpool-core/src/ens.ts
+import { PrivateKey as PrivateKey3, PublicKey as PublicKey2 } from "@hiero-ledger/sdk";
+function assertNameShape(name) {
+  if (name === "" || /[\s:]/.test(name) || !name.includes(".") || name.split(".").some((l) => l === "")) {
+    throw new Error(`not an ENS name: ${JSON.stringify(name)}`);
+  }
+  if (/[A-Z]/.test(name)) {
+    throw new Error(`ENS name must be normalised (ENSIP-15, lower case): ${JSON.stringify(name)}`);
+  }
+}
+function ensAuthorString(name, fallbackAccount, publicKeyHex) {
+  assertNameShape(name);
+  if (!ACCOUNT_RE.test(fallbackAccount)) throw new Error(`fallback account must be shard.realm.num, got ${fallbackAccount}`);
+  return `ens:${name}:${fallbackAccount}:${publicKeyHex}`;
+}
+var ACCOUNT_RE;
+var init_ens = __esm({
+  "packages/carpool-core/src/ens.ts"() {
+    "use strict";
+    ACCOUNT_RE = /^(\d+)\.(\d+)\.(\d+)$/;
+  }
+});
+
+// packages/carpool-core/src/index.ts
+var init_src = __esm({
+  "packages/carpool-core/src/index.ts"() {
+    init_units();
+    init_manifest();
+    init_magnet();
+    init_decay();
+    init_pricing();
+    init_health();
+    init_ratings();
+    init_identity();
+    init_ens();
+  }
+});
+
+// apps/mcp/src/embed.ts
+async function tryLocalEmbedder(tuple) {
+  try {
+    const spec = "@carpool/tracker";
+    const tracker = await import(
+      /* @vite-ignore */
+      spec
+    );
+    const loader = tracker.localEmbedder;
+    if (typeof loader !== "function") {
+      return { embedder: null, reason: "@carpool/tracker exports no localEmbedder" };
+    }
+    const e = await loader({
+      model: tuple.model
+    });
+    if (e.dim !== tuple.dim || e.model !== tuple.model) {
+      return {
+        embedder: null,
+        reason: `local embedder is (model="${e.model}", dim=${e.dim}) but this registry declares (model="${tuple.model}", dim=${tuple.dim}) \u2014 vectors from different models are not comparable`
+      };
+    }
+    return { embedder: { mode: "local", model: e.model, dim: e.dim, embed: (t) => e.embed(t) } };
+  } catch (err) {
+    return {
+      embedder: null,
+      reason: `local embedding unavailable (${err.message.split("\n")[0]})`
+    };
+  }
+}
+function encodeVector(v) {
+  return Buffer.from(v.buffer, v.byteOffset, v.byteLength).toString("base64");
+}
+var REMOTE_EMBED_NOTICE;
+var init_embed = __esm({
+  "apps/mcp/src/embed.ts"() {
+    "use strict";
+    REMOTE_EMBED_NOTICE = "Note: this search sent your question text to the registry, which can read and log it. Install the optional local embedding dependency to send only a vector instead (~240 MB; reduces exposure, does not make queries private \u2014 embedding inversion is real).";
+  }
+});
+
+// apps/mcp/src/client.ts
+function normaliseSummary(raw, nowMs = Date.now()) {
+  if (typeof raw.ageDays === "number") return raw;
+  const producedMs = Date.parse(raw.decay?.producedAt ?? "");
+  const ageDays = Number.isFinite(producedMs) ? Math.max(0, (nowMs - producedMs) / MS_PER_DAY) : 0;
+  return { ...raw, ageDays };
+}
+var MS_PER_DAY, RegistryClient;
+var init_client = __esm({
+  "apps/mcp/src/client.ts"() {
+    "use strict";
+    init_src();
+    init_embed();
+    MS_PER_DAY = 864e5;
+    RegistryClient = class {
+      constructor(base) {
+        this.base = base;
+      }
+      base;
+      url(path) {
+        return `${this.base.replace(/\/$/, "")}${path}`;
+      }
+      async wellKnown() {
+        const res = await fetch(this.url("/.well-known/carpool"));
+        if (!res.ok) throw new Error(`registry /.well-known/carpool \u2192 ${res.status}`);
+        return await res.json();
+      }
+      /**
+       * Search. Sends a vector when one can be produced locally, otherwise the
+       * question text — the caller decides which, and tells the user which happened.
+       *
+       * Embeds `normalizeQuestion(question)`, not the raw question: the registry
+       * indexes each artifact's `questionNorm`, so embedding the raw string would
+       * compare a differently-cased, differently-punctuated rendering of the text
+       * against the corpus and cost similarity for no reason. Both sides of the
+       * comparison now run the same normaliser from @carpool/core.
+       */
+      async search(question, limit, embedder2) {
+        const params = new URLSearchParams({ limit: String(limit) });
+        const norm = normalizeQuestion(question);
+        let sentText = true;
+        if (embedder2) {
+          params.set("vector", encodeVector(await embedder2.embed(norm)));
+          sentText = false;
+        } else {
+          params.set("q", question);
+        }
+        const res = await fetch(this.url(`/search?${params}`));
+        if (!res.ok) throw new Error(`registry /search \u2192 ${res.status}: ${await res.text()}`);
+        const body = await res.json();
+        const raw = Array.isArray(body) ? body : body.results ?? [];
+        return { results: raw.map((r) => normaliseSummary(r)), sentText };
+      }
+      /**
+       * One artifact's manifest by magnet. Free, like every other manifest read.
+       *
+       * The buyer's integrity check needs `bodyHash` fixed *before* payment; this
+       * is where it comes from when the caller has a magnet and no search result
+       * in hand. Returns null on 404/410 so a caller can distinguish "nothing to
+       * buy" from "could not check".
+       */
+      async manifest(magnet) {
+        const res = await fetch(this.url(`/manifest/${encodeURIComponent(magnet)}`));
+        if (res.status === 404 || res.status === 410) return null;
+        if (!res.ok) throw new Error(`registry /manifest \u2192 ${res.status}`);
+        return normaliseSummary(await res.json());
+      }
+    };
+  }
+});
+
+// apps/mcp/src/scan.ts
+function sweep(text, where, findings, extraTerms) {
+  let out = text;
+  for (const [re, label] of SECRET_PATTERNS) {
+    out = out.replace(re, () => {
+      findings.push({ kind: "secret", what: label, where });
+      return REDACTED;
+    });
+  }
+  out = out.replace(INTERNAL_HOST, (m) => {
+    findings.push({ kind: "internal-host", what: m, where });
+    return REDACTED;
+  });
+  out = out.replace(HOME_PATH, () => {
+    findings.push({ kind: "private-path", what: "local filesystem path", where });
+    return REDACTED;
+  });
+  for (const term of extraTerms) {
+    if (!term.trim()) continue;
+    const re = new RegExp(`\\b${term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "gi");
+    out = out.replace(re, () => {
+      findings.push({ kind: "private-repo", what: term, where });
+      return REDACTED;
+    });
+  }
+  return out;
+}
+function scanForPublish(input) {
+  const findings = [];
+  const terms = input.neverPublish ?? [];
+  const question = sweep(input.question, "question", findings, terms);
+  const abstract = sweep(input.abstract, "abstract", findings, terms);
+  const body = sweep(input.body, "body", findings, terms);
+  const sources = input.sources.filter((s) => {
+    INTERNAL_HOST.lastIndex = 0;
+    if (INTERNAL_HOST.test(s.url)) {
+      findings.push({ kind: "internal-host", what: s.url, where: "sources" });
+      return false;
+    }
+    return true;
+  });
+  return { clean: findings.length === 0, findings, redacted: { question, abstract, body, sources } };
+}
+var SECRET_PATTERNS, INTERNAL_HOST, HOME_PATH, REDACTED;
+var init_scan = __esm({
+  "apps/mcp/src/scan.ts"() {
+    "use strict";
+    SECRET_PATTERNS = [
+      [/\b(sk|pk)-[A-Za-z0-9_-]{16,}\b/g, "API key"],
+      [/\bgh[pousr]_[A-Za-z0-9]{16,}\b/g, "GitHub token"],
+      [/\bAKIA[0-9A-Z]{16}\b/g, "AWS access key id"],
+      [/\bxox[abprs]-[A-Za-z0-9-]{10,}\b/g, "Slack token"],
+      [/-----BEGIN [A-Z ]*PRIVATE KEY-----/g, "private key block"],
+      [/\b[0-9a-f]{64}\b/g, "64-hex string (possible private key)"],
+      [/\b(postgres|postgresql|mysql|mongodb(\+srv)?|redis|amqp):\/\/[^\s"']+/g, "connection string"],
+      [/\b[A-Za-z0-9._%+-]+:[^\s@"']{6,}@[A-Za-z0-9.-]+\b/g, "inline credentials"]
+    ];
+    INTERNAL_HOST = /\b(?:[a-z0-9-]+\.)*(?:internal|intranet|corp|lan|local|localdomain|test|invalid)\b|\b(?:10|127)\.\d{1,3}\.\d{1,3}\.\d{1,3}\b|\b192\.168\.\d{1,3}\.\d{1,3}\b/gi;
+    HOME_PATH = /(?:\/(?:Users|home)\/[A-Za-z0-9._-]+|[A-Z]:\\Users\\[A-Za-z0-9._-]+)[^\s"'`,)]*/g;
+    REDACTED = "[redacted]";
+  }
+});
+
+// apps/mcp/src/diff.ts
+function renderPublishDiff(input) {
+  const { redacted, findings } = input.scan;
+  const lines = [];
+  lines.push("PUBLISHING THIS RESEARCH \u2014 review before approving");
+  lines.push("");
+  lines.push("QUESTION (published verbatim, and usually the leakiest line):");
+  lines.push(`  ${redacted.question}`);
+  lines.push("");
+  lines.push("ABSTRACT:");
+  for (const l of wrap(redacted.abstract, 76)) lines.push(`  ${l}`);
+  lines.push("");
+  lines.push(`SOURCES (${redacted.sources.length}, published in full):`);
+  for (const s of redacted.sources.slice(0, 12)) lines.push(`  ${s.url}`);
+  if (redacted.sources.length > 12) lines.push(`  \u2026 and ${redacted.sources.length - 12} more`);
+  lines.push("");
+  if (findings.length > 0) {
+    lines.push(`REMOVED BY THE PRE-PUBLISH SCAN (${findings.length}):`);
+    for (const f of findings) lines.push(`  ${f.where}: ${f.what} (${f.kind})`);
+    lines.push("");
+    lines.push("  These were stripped, not flagged \u2014 they are already gone from what would be published.");
+  } else {
+    lines.push("PRE-PUBLISH SCAN: nothing removed.");
+  }
+  lines.push("");
+  lines.push(
+    `BODY: ${fmtBytes(input.bodyBytes)} \u2014 not shown here. Ask to see it before approving if you want to read it.`
+  );
+  lines.push("");
+  lines.push(
+    `TERMS: listed at ${(input.priceMicroUsdc / 1e6).toFixed(4)} USDC, halving every ${input.halfLifeDays} day(s).`
+  );
+  lines.push(
+    "IRREVERSIBLE: delisting stops new sales. It cannot recall a copy someone has already paid for."
+  );
+  return lines.join("\n");
+}
+function wrap(text, width) {
+  const words = text.split(/\s+/);
+  const out = [];
+  let line = "";
+  for (const w of words) {
+    if ((line + " " + w).trim().length > width) {
+      out.push(line.trim());
+      line = w;
+    } else line += " " + w;
+  }
+  if (line.trim()) out.push(line.trim());
+  return out;
+}
+function fmtBytes(n) {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  return `${(n / (1024 * 1024)).toFixed(2)} MB`;
+}
+var init_diff = __esm({
+  "apps/mcp/src/diff.ts"() {
+    "use strict";
+  }
+});
+
+// apps/mcp/src/render.ts
+function usd(micro) {
+  return `$${(micro / 1e6).toFixed(4)}`;
+}
+function renderCandidate(m, i, capMicroUsdc2 = CAP_MICRO_USDC) {
+  const p = m.provenance;
+  const overCap = m.priceNow > capMicroUsdc2;
+  const match = m.similarity != null && m.score != null ? `   match: similarity ${m.similarity.toFixed(2)} \xB7 depth ${(m.depth ?? 0).toFixed(2)} \xB7 score ${m.score.toFixed(3)}` : null;
+  return [
+    `${i + 1}. ${m.question}`,
+    `   ${m.magnet}`,
+    `   price ${usd(m.priceNow)}${overCap ? ` \u2014 OVER your ${usd(capMicroUsdc2)} spend cap; carpool_fetch will refuse it` : ""} \xB7 ${m.ageDays.toFixed(1)}d old \xB7 freshness ${m.freshness.toFixed(2)} \xB7 health ${m.health.toFixed(2)}`,
+    ...match ? [match] : [],
+    `   cost to produce: ${p.model}, ${p.durationSeconds}s, ${p.inputTokens + p.outputTokens} tokens, ${p.toolCalls} tool calls, $${p.estimatedCostUsd.toFixed(2)}`,
+    `   ${m.sources.length} sources: ${m.sources.slice(0, 3).map((s) => s.url).join(", ")}${m.sources.length > 3 ? " \u2026" : ""}`,
+    `   ${m.abstract.slice(0, 220)}${m.abstract.length > 220 ? "\u2026" : ""}`
+  ].join("\n");
+}
+function renderIntegrity(result, digest) {
+  const short = `sha256 ${digest.slice(0, 16)}\u2026`;
+  if (result.verification.state === "verified") {
+    return `${short} \u2014 verified: matches the bodyHash in the manifest read before paying`;
+  }
+  return `${short} \u2014 NOT VERIFIED (${result.verification.reason}). Treat the content as unchecked: it was not compared against a hash fixed before payment.`;
+}
+var CAP_MICRO_USDC;
+var init_render = __esm({
+  "apps/mcp/src/render.ts"() {
+    "use strict";
+    init_src();
+    CAP_MICRO_USDC = capMicroUsdc();
+  }
+});
+
+// apps/mcp/src/pay.ts
+var pay_exports = {};
+__export(pay_exports, {
+  payFetch: () => payFetch
+});
+import { createClientHederaSigner, PrivateKey as PrivateKey4 } from "@x402/hedera";
+import { ExactHederaScheme } from "@x402/hedera/exact/client";
+import { wrapFetchWithPayment, x402Client, decodePaymentResponseHeader } from "@x402/fetch";
+import { createHash as createHash3 } from "node:crypto";
+function decodeTx(res) {
+  const raw = res.headers.get("PAYMENT-RESPONSE") ?? res.headers.get("payment-response");
+  if (!raw) return "";
+  try {
+    return decodePaymentResponseHeader(raw).transaction ?? "";
+  } catch {
+    return "";
+  }
+}
+async function payFetch(base, magnet, expectedBodyHash) {
+  const accountId = process.env.CARPOOL_BUYER_ACCOUNT_ID;
+  const key = process.env.CARPOOL_BUYER_PRIVATE_KEY;
+  const network = process.env.HEDERA_NETWORK ?? "hedera:testnet";
+  const asset = process.env.USDC_TOKEN_ID ?? "0.0.429274";
+  const unpaid = (error) => ({
+    ok: false,
+    body: "",
+    paid: 0,
+    txId: "",
+    verification: { state: "unverified", reason: "nothing was bought" },
+    error
+  });
+  if (!accountId || !key) {
+    return unpaid(
+      "no buyer credentials: set CARPOOL_BUYER_ACCOUNT_ID and CARPOOL_BUYER_PRIVATE_KEY. carpool_search works without them; only buying needs a funded account."
+    );
+  }
+  let expected = expectedBodyHash ?? null;
+  let expectedError = null;
+  if (!expected) {
+    try {
+      const manifest = await new RegistryClient(base).manifest(magnet);
+      if (!manifest) return unpaid("no such artifact (or it is delisted or expired)");
+      expected = manifest.bodyHash;
+    } catch (e) {
+      expectedError = `could not fetch the manifest to verify against (${e.message})`;
+    }
+  }
+  const url = `${base.replace(/\/$/, "")}/artifact/${encodeURIComponent(magnet)}`;
+  const probe = await fetch(url);
+  if (probe.status === 404) return unpaid("no such artifact");
+  if (probe.status === 410) return unpaid("artifact is delisted or expired");
+  if (probe.status !== 402) {
+    let detail = "";
+    try {
+      detail = (await probe.text()).trim().replace(/\s+/g, " ").slice(0, 300);
+    } catch {
+    }
+    return unpaid(
+      `the registry answered ${probe.status} instead of quoting a price` + (detail ? `: ${detail}` : "") + ". Nothing was charged, and this is the registry's end rather than your credentials."
+    );
+  }
+  const quoted = await probe.json();
+  const paid = Number(quoted.accepts?.[0]?.amount ?? 0);
+  const signer = createClientHederaSigner(accountId, PrivateKey4.fromStringECDSA(key), { network });
+  const client = x402Client.fromConfig({
+    schemes: [{ network, client: new ExactHederaScheme(signer) }],
+    spendControls: {
+      allowedAssets: [
+        { network, asset, maxAmountPerPayment: MAX_PER_PAYMENT }
+      ]
+    }
+  });
+  const paidFetch = wrapFetchWithPayment(fetch, client);
+  let res;
+  try {
+    res = await paidFetch(url);
+  } catch (e) {
+    return {
+      ...unpaid(
+        `payment was not attempted (${e.message}). The quote was ${paid} \xB5USDC and this client's per-payment cap is ${MAX_PER_PAYMENT} \xB5USDC \u2014 raise CARPOOL_MAX_MICRO_USDC to buy it. At the default price rule that cap buys research costing up to $${maxBuyableRedoCostUsd(Number(MAX_PER_PAYMENT)).toFixed(2)} to produce.`
+      ),
+      paid
+    };
+  }
+  if (!res.ok) {
+    return { ...unpaid(`paid fetch \u2192 ${res.status}`), paid, txId: decodeTx(res) };
+  }
+  const body = await res.text();
+  const txId = decodeTx(res);
+  if (!expected) {
+    return {
+      ok: true,
+      body,
+      paid,
+      txId,
+      verification: {
+        state: "unverified",
+        reason: expectedError ?? "no manifest bodyHash was available to compare against"
+      }
+    };
+  }
+  const actual = createHash3("sha256").update(body).digest("hex");
+  if (actual !== expected) {
+    return {
+      ok: false,
+      body: "",
+      paid,
+      txId,
+      verification: { state: "unverified", reason: "the delivered body did not match the manifest" },
+      error: `body hash mismatch: the manifest says ${expected.slice(0, 16)}\u2026 but the registry served ${actual.slice(0, 16)}\u2026. Paid, but the content is not what was sold \u2014 keep the transaction id and request a refund.`
+    };
+  }
+  return { ok: true, body, paid, txId, verification: { state: "verified", source: "manifest", bodyHash: expected } };
+}
+var MAX_PER_PAYMENT;
+var init_pay = __esm({
+  "apps/mcp/src/pay.ts"() {
+    "use strict";
+    init_client();
+    init_src();
+    MAX_PER_PAYMENT = String(capMicroUsdc());
+  }
+});
+
+// apps/mcp/src/publish.ts
+var publish_exports = {};
+__export(publish_exports, {
+  publishArtifact: () => publishArtifact
+});
+async function publishArtifact(base, input) {
+  const accountId = process.env.CARPOOL_AUTHOR_ACCOUNT_ID;
+  const key = process.env.CARPOOL_AUTHOR_PRIVATE_KEY;
+  if (!accountId || !key) {
+    return {
+      ok: false,
+      error: "no author credentials: set CARPOOL_AUTHOR_ACCOUNT_ID and CARPOOL_AUTHOR_PRIVATE_KEY. Royalties are paid to this account."
+    };
+  }
+  let author;
+  try {
+    const publicKeyHex = publicKeyHexOf(key);
+    const ensName = process.env.CARPOOL_AUTHOR_ENS_NAME?.trim();
+    if (ensName) {
+      try {
+        author = ensAuthorString(ensName, accountId, publicKeyHex);
+      } catch (e) {
+        return {
+          ok: false,
+          error: `CARPOOL_AUTHOR_ENS_NAME is not usable: ${e.message}. Unset it to publish under the account id alone.`
+        };
+      }
+    } else {
+      author = `${accountId}:${publicKeyHex}`;
+    }
+  } catch (e) {
+    return {
+      ok: false,
+      error: `CARPOOL_AUTHOR_PRIVATE_KEY is not a usable ECDSA private key (${e.message.split("\n")[0]}). The registry verifies publishes against the public key derived from it, so publishing cannot proceed without one.`
+    };
+  }
+  const { createHash: createHash5 } = await import("node:crypto");
+  const bodyHash = createHash5("sha256").update(input.body).digest("hex");
+  const withoutMagnet = {
+    question: input.question,
+    // @carpool/core's normaliser, the same function the registry recomputes
+    // and rejects a mismatch against. This file used to carry a private copy
+    // that stripped a different punctuation set — and since questionNorm is
+    // inside the content-addressed manifest, the two copies produced two
+    // different magnets for one question.
+    questionNorm: normalizeQuestion(input.question),
+    scope: input.scope,
+    abstract: input.abstract,
+    sources: input.sources,
+    provenance: input.provenance,
+    decay: { halfLifeDays: input.halfLifeDays, producedAt: (/* @__PURE__ */ new Date()).toISOString() },
+    author,
+    bodyHash,
+    bodyBytes: Buffer.byteLength(input.body, "utf8"),
+    redacted: input.redacted
+  };
+  const magnet = magnetOf(withoutMagnet);
+  const manifest = { ...withoutMagnet, magnet };
+  const authorSig = signManifest(key, magnet.replace(/^swarm:/, ""));
+  const res = await fetch(`${base.replace(/\/$/, "")}/publish`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      manifest,
+      body: input.body,
+      // `authorSig`, not `signature`: the registry's PublishBody schema
+      // requires this name and zod rejected the request before any of the
+      // cryptography ran.
+      authorSig,
+      priceBase: input.priceMicroUsdc,
+      priceFloor: floorForPrice(input.priceMicroUsdc)
+    })
+  });
+  if (!res.ok) return { ok: false, error: `registry /publish \u2192 ${res.status}: ${await res.text()}` };
+  const json = await res.json();
+  return { ok: true, magnet, duplicateOf: json.duplicateOf ?? null };
+}
+var init_publish = __esm({
+  "apps/mcp/src/publish.ts"() {
+    "use strict";
+    init_src();
+  }
+});
+
+// apps/mcp/src/delist.ts
+var delist_exports = {};
+__export(delist_exports, {
+  delistArtifact: () => delistArtifact
+});
+async function delistArtifact(base, magnet) {
+  const key = process.env.CARPOOL_AUTHOR_PRIVATE_KEY;
+  if (!key) {
+    return {
+      ok: false,
+      error: "no author credentials: set CARPOOL_AUTHOR_PRIVATE_KEY. Only the author who published an artifact can withdraw it, and the registry checks that against the key inside the manifest."
+    };
+  }
+  let authorSig;
+  try {
+    authorSig = signManifest(key, sha256(`${magnet}:delist`));
+  } catch (e) {
+    return {
+      ok: false,
+      error: `CARPOOL_AUTHOR_PRIVATE_KEY is not a usable ECDSA private key (${e.message.split("\n")[0]}).`
+    };
+  }
+  const res = await fetch(`${base.replace(/\/$/, "")}/delist`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ magnet, authorSig })
+  });
+  if (!res.ok) {
+    const detail = await res.text();
+    if (res.status === 401) {
+      return {
+        ok: false,
+        error: `the registry does not accept this key as ${magnet}'s author (401). Only the publishing account can withdraw an artifact. ${detail}`
+      };
+    }
+    if (res.status === 404) return { ok: false, error: `no such artifact: ${magnet}` };
+    return { ok: false, error: `registry /delist \u2192 ${res.status}: ${detail}` };
+  }
+  const json = await res.json();
+  return { ok: true, ...json };
+}
+var init_delist = __esm({
+  "apps/mcp/src/delist.ts"() {
+    "use strict";
+    init_src();
+  }
+});
+
+// apps/mcp/src/server.ts
+var server_exports = {};
+__export(server_exports, {
+  carpoolDelist: () => carpoolDelist,
+  carpoolFetch: () => carpoolFetch,
+  carpoolPublish: () => carpoolPublish,
+  carpoolSearch: () => carpoolSearch,
+  server: () => server
+});
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import "@modelcontextprotocol/sdk/server/stdio.js";
+import { z as z2 } from "zod";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { createHash as createHash4 } from "node:crypto";
+async function ensureEmbedder() {
+  if (embedder) return;
+  const wk = await registry.wellKnown();
+  const attempt = await tryLocalEmbedder(wk.embedding);
+  if (attempt.embedder) embedder = attempt.embedder;
+  else embedReason = attempt.reason;
+}
+async function carpoolSearch({
+  question,
+  limit
+}) {
+  {
+    await ensureEmbedder();
+    const { results, sentText } = await registry.search(question, limit ?? 5, embedder);
+    if (results.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `No prior research found for: ${question}
+
+Do the research yourself.` + (sentText ? `
+
+${REMOTE_EMBED_NOTICE}${embedReason ? ` Reason: ${embedReason}.` : ""}` : "")
+          }
+        ]
+      };
+    }
+    const body = results.map((m, i) => renderCandidate(m, i)).join("\n\n");
+    const affordable = results.filter((r) => r.priceNow <= CAP_MICRO_USDC);
+    const cheapest = affordable.length > 0 ? Math.min(...affordable.map((r) => r.priceNow)) : null;
+    const dearestToRedo = Math.max(...results.map((r) => r.provenance.estimatedCostUsd));
+    return {
+      content: [
+        {
+          type: "text",
+          text: `${results.length} candidate(s) for: ${question}
+
+${body}
+
+` + (cheapest === null ? `All of these are above your ${usd(CAP_MICRO_USDC)} per-payment cap (which buys research costing up to $${maxBuyableRedoCostUsd(CAP_MICRO_USDC).toFixed(2)} to produce); raise CARPOOL_MAX_MICRO_USDC to buy one. ` : `Buying the cheapest costs ${usd(cheapest)}; `) + `the most expensive of these cost $${dearestToRedo.toFixed(2)} to produce. Use carpool_fetch <magnet> to buy one.` + (sentText ? `
+
+${REMOTE_EMBED_NOTICE}${embedReason ? ` Reason: ${embedReason}.` : ""}` : "")
+        }
+      ]
+    };
+  }
+}
+async function carpoolFetch({ magnet }) {
+  {
+    const { payFetch: payFetch2 } = await Promise.resolve().then(() => (init_pay(), pay_exports));
+    const result = await payFetch2(REGISTRY, magnet);
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: `Could not buy ${magnet}: ${result.error}` }],
+        isError: true
+      };
+    }
+    mkdirSync(OUT_DIR, { recursive: true });
+    const name = `${magnet.replace(/^swarm:/, "").slice(0, 16)}.md`;
+    const path = join(OUT_DIR, name);
+    writeFileSync(path, result.body, "utf8");
+    const bytes = Buffer.byteLength(result.body, "utf8");
+    const digest = createHash4("sha256").update(result.body).digest("hex");
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Bought ${magnet} for ${usd(result.paid)}.
+Written to: ${path}
+${bytes} bytes \xB7 ${renderIntegrity(result, digest)}
+Transaction: ${result.txId || "(none reported)"}
+
+Read the file for the research. You did not have to run it.`
+        }
+      ]
+    };
+  }
+}
+async function carpoolPublish(args) {
+  {
+    const scan = scanForPublish({
+      question: args.question,
+      abstract: args.abstract,
+      body: args.body,
+      sources: args.sources,
+      neverPublish: args.neverPublish
+    });
+    const priceMicro = priceForRedoCost(args.provenance.estimatedCostUsd);
+    const halfLife = args.halfLifeDays ?? 1;
+    if (!args.confirm) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: renderPublishDiff({
+              scan,
+              bodyBytes: Buffer.byteLength(scan.redacted.body, "utf8"),
+              priceMicroUsdc: priceMicro,
+              halfLifeDays: halfLife
+            }) + "\n\nNothing has been published. Show this to the user and call again with confirm: true only if they approve."
+          }
+        ]
+      };
+    }
+    const { publishArtifact: publishArtifact2 } = await Promise.resolve().then(() => (init_publish(), publish_exports));
+    const out = await publishArtifact2(REGISTRY, {
+      ...args,
+      ...scan.redacted,
+      halfLifeDays: halfLife,
+      priceMicroUsdc: priceMicro,
+      redacted: !scan.clean
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: out.ok ? `Published ${out.magnet} at ${usd(priceMicro)}, halving every ${halfLife} day(s).` + (scan.clean ? "" : ` ${scan.findings.length} item(s) were stripped before publishing.`) + (out.duplicateOf ? `
+
+Note: ${out.duplicateOf} already answers the same normalised question. Both are live and the tracker ranks between them \u2014 yours is not a replacement.` : "") : `Publish failed: ${out.error}`
+        }
+      ],
+      isError: !out.ok
+    };
+  }
+}
+async function carpoolDelist({ magnet }) {
+  {
+    const { delistArtifact: delistArtifact2 } = await Promise.resolve().then(() => (init_delist(), delist_exports));
+    const out = await delistArtifact2(REGISTRY, magnet);
+    if (!out.ok) {
+      return { content: [{ type: "text", text: `Could not delist ${magnet}: ${out.error}` }], isError: true };
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: (out.alreadyDelisted ? `${magnet} was already withdrawn (at ${new Date(out.delistedAt * 1e3).toISOString()}).` : `Withdrawn ${magnet} from sale.`) + `
+
+${out.note}`
+        }
+      ]
+    };
+  }
+}
+var REGISTRY, OUT_DIR, registry, embedder, embedReason, server;
+var init_server = __esm({
+  async "apps/mcp/src/server.ts"() {
+    "use strict";
+    init_client();
+    init_embed();
+    init_scan();
+    init_diff();
+    init_render();
+    init_src();
+    REGISTRY = process.env.CARPOOL_REGISTRY_URL ?? "http://localhost:8403";
+    OUT_DIR = process.env.CARPOOL_ARTIFACT_DIR ?? join(tmpdir(), "carpool-artifacts");
+    registry = new RegistryClient(REGISTRY);
+    embedder = null;
+    embedReason = "";
+    server = new McpServer({ name: "carpool", version: "0.1.0" });
+    server.registerTool(
+      "carpool_search",
+      {
+        title: "Search prior research before doing your own",
+        description: "Call this BEFORE starting deep research. Returns prior research artifacts whose question matches yours, with what each cost to produce, how stale it is, and what it costs to buy. Free \u2014 no payment is made by this tool. Read the evidence and decide whether buying beats redoing the work.",
+        inputSchema: { question: z2.string().min(3), limit: z2.number().int().min(1).max(20).optional() }
+      },
+      carpoolSearch
+    );
+    server.registerTool(
+      "carpool_fetch",
+      {
+        title: "Buy an artifact and write it to a file",
+        description: "Pays for an artifact over x402 and writes it to a file, returning the path and a summary. It does NOT return the body inline: an MCP tool result is capped at ~25k tokens and a real artifact does not fit. Writing to a file also keeps the context cost under your control, which is the saving this whole system exists to produce \u2014 read only the parts you need.",
+        inputSchema: { magnet: z2.string().startsWith("swarm:") }
+      },
+      carpoolFetch
+    );
+    server.registerTool(
+      "carpool_publish",
+      {
+        title: "List research you already did, for sale",
+        description: "Publishes a completed research artifact so the next person with the same question can buy it instead of redoing the work. IRREVERSIBLE: carpool_delist stops new sales but cannot recall a copy someone has already paid for. Requires explicit approval every time; never available to subagents, and turned off entirely by CARPOOL_PUBLISH_MODE=off.",
+        inputSchema: {
+          question: z2.string().min(3),
+          abstract: z2.string().min(10),
+          body: z2.string().min(1),
+          sources: z2.array(z2.object({ url: z2.string().url(), fetchedAt: z2.string() })),
+          provenance: z2.object({
+            model: z2.string(),
+            durationSeconds: z2.number(),
+            inputTokens: z2.number(),
+            outputTokens: z2.number(),
+            estimatedCostUsd: z2.number(),
+            toolCalls: z2.number()
+          }),
+          scope: z2.string().optional(),
+          halfLifeDays: z2.number().positive().optional(),
+          neverPublish: z2.array(z2.string()).optional(),
+          confirm: z2.boolean().optional()
+        }
+      },
+      carpoolPublish
+    );
+    server.registerTool(
+      "carpool_delist",
+      {
+        title: "Withdraw research you published, from sale",
+        description: "Stops new sales of an artifact you published. What it CANNOT do: recall a copy someone has already paid for, cancel a buyer's refund window, or cancel a royalty you have already earned (you still get paid for sales that happened). Final for that magnet: republishing the same research does not relist it. Requires the author credentials the artifact was published with.",
+        inputSchema: { magnet: z2.string().startsWith("swarm:") }
+      },
+      carpoolDelist
+    );
+    if (false) {
+      await server.connect(new StdioServerTransport());
+    }
+  }
+});
+
+// apps/mcp/scripts/npm-cli.ts
+import { readFileSync } from "node:fs";
+var sub = process.argv[2];
+function emitDeny(reason) {
+  process.stdout.write(
+    JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "deny",
+        permissionDecisionReason: reason
+      }
+    })
+  );
+  process.exit(0);
+}
+if (sub === "associate") {
+  const { associateAccount: associateAccount2, InputError: InputError2 } = await Promise.resolve().then(() => (init_associate_account_run(), associate_account_run_exports));
+  associateAccount2().then(
+    (code) => process.exit(code),
+    (e) => {
+      console.error(e instanceof InputError2 ? e.message : `failed: ${e.message}`);
+      process.exit(1);
+    }
+  );
+} else if (sub === "consent-hook") {
+  try {
+    let input;
+    try {
+      input = JSON.parse(readFileSync(0, "utf8"));
+    } catch {
+      emitDeny("carpool publish hook could not read its input; refusing rather than guessing.");
+    }
+    const { decideConsent: decideConsent2, hookOutput: hookOutput2 } = await Promise.resolve().then(() => (init_consent(), consent_exports));
+    const out = hookOutput2(decideConsent2(input, { mode: process.env.CARPOOL_PUBLISH_MODE }));
+    process.stdout.write(JSON.stringify(out));
+  } catch (e) {
+    emitDeny(`carpool publish hook failed (${e.message}); refusing rather than guessing.`);
+  }
+} else if (sub === void 0 || sub === "serve") {
+  const { StdioServerTransport: StdioServerTransport2 } = await import("@modelcontextprotocol/sdk/server/stdio.js");
+  const { server: server2 } = await init_server().then(() => server_exports);
+  await server2.connect(new StdioServerTransport2());
+} else if (sub === "--version" || sub === "-v") {
+  console.log("carpool-mcp 0.1.0");
+} else {
+  console.error(
+    `carpool-mcp: unknown command "${sub}".
+Usage: carpool-mcp            start the MCP server on stdio
+       carpool-mcp associate  associate HEDERA_ACCOUNT_ID with test USDC (key from HEDERA_PRIVATE_KEY env)
+       carpool-mcp consent-hook  PreToolUse hook for carpool_publish`
+  );
+  process.exit(2);
+}