@fangorn-network/westmarch 2026.10.29 → 2026.11.4-dev

package/src/agent/tools.js

@@ -29,7 +29,8 @@ const PLUMBING = new Set(["text", "vector", "norm", "id", "owner", "embed"]);
 export const brief = (r, roles, fields = []) => {
     const out = briefOf(r, roles, fields);
     const link = linkOf(r, roles);
-    return link ? { ...out, url: link } : out;
+    // Whose it is, and its price when sold: what an agent needs to cite or buy a hit.
+    return { ...out, ...(link ? { url: link } : {}), ...(r.owner ? { publisher: r.owner } : {}), ...(r.sale ? { sale: r.sale } : {}) };
 };
 
 /**

package/src/agent/view-tools.js

@@ -11,7 +11,7 @@
 //   - a search goes to the 3 views whose coverage sketch best matches the query,
 //     not to all of them (Kingsfoil: ~3 of 23 views, ~92% of the true top 10 with
 //     a 32-vector sketch). The result names what was searched and what was not.
-//   - `warm()` starts the embedder before the first query (fangorn-mcp: on find-apps), and a search
+//   - `warm()` starts the embedder before the first query, and a search
 //     never waits on a first-time model download.
 //
 // `get`/`similar`/`count` answer over what is loaded, and say so.
@@ -86,6 +86,7 @@ export function viewTools(app, { fetchCatalog = fetch, queryVector: embedQ = que
             view, name: label(view),
             description: domains.map((d) => d.description).filter(Boolean).join(" "),
             count: domains.reduce((s, d) => s + (d.count ?? 0), 0),
+            repos: domains.filter((d) => d.publisher).map((d) => ({ publisher: d.publisher, repo: d.repo, rows: d.count ?? 0, description: d.description ?? "" })),
             coverage: { vectors: domains.flatMap((d) => d.coverage?.vectors ?? []) },
         };
     })).catch((e) => { surveyed = null; throw e; }));
@@ -112,7 +113,8 @@ export function viewTools(app, { fetchCatalog = fetch, queryVector: embedQ = que
     const run = {
         describe: async () => ({
             app: app.name, description: app.desc,
-            views: (await survey()).map((v) => ({ view: v.name, rows: v.count, description: v.description, loaded: loaded.has(v.view) })),
+            views: (await survey()).map((v) => ({ view: v.name, rows: v.count, description: v.description, loaded: loaded.has(v.view),
+                                                  ...(v.repos.length ? { repos: v.repos } : {}) })),
         }),
         search: async ({ query, limit = 10, views, where: w }) => {
             if (!query) throw new Error("query is required");
@@ -176,60 +178,6 @@ export function viewTools(app, { fetchCatalog = fetch, queryVector: embedQ = que
         { name: "threads", description: `One thing followed across records of a ${n} view (a matter from committee to council): steps in date order, the latest-moving first. Views that declare no thread say so.`,
           inputSchema: { type: "object", properties: { view: str("View name from describe"), id: str("One thread, by a step's thread field"), limit: num("default 20"), offset: num("default 0"), where: WHERE }, required: ["view"] } },
     ];
-    // Records the app sells over x402 (its card's `paid`). Paid from this server's wallet,
-    // never above FANGORN_MCP_MAX_PRICE, and checked against the sha256 the app published
-    // for that record, so what was paid for is what was committed.
-    if (app.paid) {
-        const p = app.paid, dec = p.decimals ?? 6;
-        const price = `${(Number(p.price) / 10 ** dec).toFixed(dec).replace(/0+$/, "").replace(/\.$/, "")} ${p.symbol ?? "USDC"}`;
-        const cap = BigInt(Math.round(Number(process.env.FANGORN_MCP_MAX_PRICE ?? "0.10") * 10 ** dec));
-        const resolve = (id) => {
-            const hit = loadedRows().find(({ r, view }) => r.id === id || r[rolesOf(view).identity] === id);
-            return { key: hit ? hit.r[rolesOf(hit.view).identity] ?? id : id, want: hit?.r.paid_sha256, ct: hit?.r.paid_ct };
-        };
-        run.buy = async ({ id, ids }) => {
-            const { buyBatch, withLock } = await import("./x402.js");
-            const rs = (ids?.length ? ids : id ? [id] : []).map(resolve);
-            const ct = Object.fromEntries(rs.filter((r) => r.ct).map((r) => [r.key, r.ct]));
-            const want = Object.fromEntries(rs.filter((r) => r.want).map((r) => [r.key, r.want]));
-            const verdict = (records) => { const bad = records.filter((x) => x.verified === false).map((x) => x.id);
-                return bad.length ? `MISMATCH for ${bad.join(", ")}` : "every record opened matches its published sha256"; };
-            if (ids?.length) {
-                // Many at once, one price: from the allowance file (FANGORN_MCP_VOUCHERS, vouchers the
-                // person's wallet signed) if there is one, else one payment from the wallet key.
-                const fs = await import("node:fs");
-                const vf = process.env.FANGORN_MCP_VOUCHERS;
-                const opts = { ct, want, privateKey: process.env.FANGORN_MCP_WALLET_KEY, maxPrice: cap * BigInt(rs.length) };
-                // The file is read, spent from and saved under one lock, and saved even when the
-                // purchase fails: buyBatch drops the vouchers the seller settled or refused either way.
-                const r = vf
-                    ? await withLock(vf, async () => {
-                        const vouchers = JSON.parse(fs.readFileSync(vf, "utf8"));
-                        try { return await buyBatch(p, rs.map((r) => r.key), { ...opts, vouchers }); }
-                        finally { fs.writeFileSync(vf, JSON.stringify(vouchers)); }
-                    })
-                    : await buyBatch(p, rs.map((r) => r.key), opts);
-                return { bought: r.records.length, missing: r.missing, verified: verdict(r.records),
-                         ...(r.undelivered.length ? { not_bought: r.undelivered, why: r.error } : {}),
-                         manifest: r.manifest, records: r.records.map(({ id, record, error }) => ({ id, record, error })) };
-            }
-            if (!id) throw new Error("id or ids is required");
-            const { key, want: w, ct: c } = resolve(id);
-            if (!c) return { id: key, error: "search for the record first: its sealed copy (paid_ct) comes from the row, and nothing is bought without it" };
-            const { buyRecord } = await import("./x402.js");
-            const r = await buyRecord(p, key, { ct: c, want: w, privateKey: process.env.FANGORN_MCP_WALLET_KEY, maxPrice: cap });
-            if (r.error) return r;
-            return { id: key, paid: r.price ? price : "free", transaction: r.receipt?.transaction ?? null, network: r.receipt?.network ?? p.network,
-                     verified: w ? (r.verified ? "matches the published sha256" : `MISMATCH: published ${w}, got ${r.digest}`) : "not checked (the row has no paid_sha256)",
-                     record: r.record };
-        };
-        tools.push({ name: "buy", description: `Buy one ${n} record's paid detail for ${price} (x402 on ${p.network}): ${p.description || "the structured record"}. ` +
-                "Pass an id from search, or ids for up to 1000 at once (one price, one manifest of hashes and transactions). " +
-                "The record is already in the row, sealed; this buys its key and opens it. " +
-                "Paid from the allowance (FANGORN_MCP_VOUCHERS) or this server's wallet (FANGORN_MCP_WALLET_KEY), never above FANGORN_MCP_MAX_PRICE a record.",
-            inputSchema: { type: "object", properties: { id: str("A record id from search or get"), ids: { type: "array", items: { type: "string" }, description: "Several record ids, bought together" } } } });
-    }
-
     return { tools, call: async (name, args = {}) => {
         if (!run[name]) throw new Error(`no tool ${name}`);
         return text(await run[name](args));