@fangorn-network/westmarch 0.0.9-dev → 0.0.11-dev

package/site/dist/index.html

@@ -1,8 +1,8 @@
 <!doctype html>
 <html lang="en">
-<script type="module" crossorigin src="./assets/index-w2wfUwhm.js"></script>
+<script type="module" crossorigin src="./assets/index-oyUqokZh.js"></script>
 <link rel="modulepreload" crossorigin href="./assets/rolldown-runtime-Dd_uD5pT.js">
-<link rel="modulepreload" crossorigin href="./assets/preload-helper-uBIymjUX.js">
+<link rel="modulepreload" crossorigin href="./assets/preload-helper-BaNbYf_w.js">
 <link rel="modulepreload" crossorigin href="./assets/roles-C9V_uDr_.js">
 
 <meta charset="utf-8">

package/site/feed.js

@@ -2,7 +2,7 @@
 // occasion (a meeting, an issue, an episode), from the roles the app declared. Nothing here
 // knows what a row is: an occasion is the rows sharing a subtitle and a facet value, and
 // its date is their temporal field.
-import { pick, subtitleOf, titleOf, values } from "../consume/roles.js";
+import { pick, subtitleOf, titleOf, values } from "../src/core/roles.js";
 
 /** The field a reader narrows by first: the app's declared facet, else the first tag with
  *  a handful of values (a town, not every body in every town). */
@@ -45,7 +45,7 @@ export function detail(r, roles) {
 
 // ── self-check: `node site/feed.js` ──
 if (typeof process !== "undefined" && process.argv[1]?.endsWith("/feed.js")) {
-    const { rolesFrom } = await import("../consume/roles.js");
+    const { rolesFrom } = await import("../src/core/roles.js");
     const roles = rolesFrom([{ role_map: { title: "heading", subtitle: "meeting", temporal: "date", tags: ["city", "body"], text: ["text"] },
                                presentation: { facets: ["city"] } }]);
     const row = (city, date, heading, text = heading) => ({ city, date, heading, meeting: `Board · ${date}`, body: "Board", text });

package/site/store.js

@@ -1,12 +1,12 @@
 // What a person does on the page, kept on their own device: what they saved, what they
 // passed on, and what they searched this session. Nothing leaves the browser unless they
-// export it. The saved items are also the likes a taste is built from (consume/taste.js),
+// export it. The saved items are also the likes a taste is built from (src/taste/taste.js),
 // so "For you" is theirs, and so is the file they can hand an agent.
 //
 // Saved items are snapshots keyed by the publisher's own id (the identity role), not the
 // row's CID: a record re-published with a new CID must still be the item they saved.
-import { exportTaste, taste } from "../consume/taste.js";
-import { packVec, unpackVec } from "../consume/embed.js";
+import { exportTaste, taste } from "../src/taste/taste.js";
+import { packVec, unpackVec } from "../src/core/embed.js";
 
 const read = (s, k, dflt) => { try { return JSON.parse(s?.getItem(k) ?? "null") ?? dflt; } catch { return dflt; } };
 const write = (s, k, v) => { try { s?.setItem(k, JSON.stringify(v)); } catch { /* private mode or full: the page still works */ } };

package/{publish → src/agent}/agent-card.js

@@ -106,13 +106,13 @@ export function fangornExtension({ app, fromBlock, namespaces = [], views = [],
     };
 }
 
-// ── self-check: `node publish/agent-card.js` ────────────────────────────────
+// ── self-check: `node src/agent/agent-card.js` ────────────────────────────────
 if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/agent-card.js")) {
     const eq = (a, b, m) => { if (JSON.stringify(a) !== JSON.stringify(b)) throw new Error(`${m}: ${JSON.stringify(a)} != ${JSON.stringify(b)}`); };
     const throws = (f, re, m) => { try { f(); } catch (e) { if (re.test(e.message)) return; throw e; } throw new Error(`must throw: ${m}`); };
 
-    const { APP_EXTENSION } = await import("../consume/apps.js");
-    eq(APP_EXTENSION, FANGORN_APP_EXTENSION, "consume/apps.js's copy of the extension uri");
+    const { APP_EXTENSION } = await import("../discover/apps.js");
+    eq(APP_EXTENSION, FANGORN_APP_EXTENSION, "src/discover/apps.js's copy of the extension uri");
 
     let fired = 0;
     const tools = await captureTools(() => {

package/{consume → src/agent}/mcp-bin.js

@@ -2,5 +2,5 @@
 // Static imports run in order, so the library is loaded before the server
 // starts. Not `await import("./mcp.js")`: bun 1.1 then wraps each module in a
 // function, and their top-level awaits stop parsing.
-import "./ort-preload.js";
+import "../core/ort-preload.js";
 import "./mcp.js";

package/{consume → src/agent}/mcp.js

@@ -29,7 +29,7 @@ import { createHash } from "node:crypto";
 import net from "node:net";
 import { homedir } from "node:os";
 import { createInterface } from "node:readline";
-import { APP_EXTENSION, listApps, toApp } from "./apps.js";
+import { APP_EXTENSION, listApps, toApp } from "../discover/apps.js";
 
 // The current AppRegistry's first event on Arbitrum Sepolia. A reader's
 // default, not deployment config: pass --from-block for another deployment.
@@ -522,12 +522,12 @@ const deps = {
     // ponytail: cached for a minute, like findApps. Two getLogs, a card and catalog per app.
     exploreApps: async (query) => {
         if (!explored || Date.now() - exploredAt > 60_000) {
-            const [ex, { createPublicClient, http }, { arbitrumSepolia }] = await Promise.all([import("./explore.js"), import("viem"), import("viem/chains")]);
+            const [ex, { createPublicClient, http }, { arbitrumSepolia }] = await Promise.all([import("../discover/explore.js"), import("viem"), import("viem/chains")]);
             explored = { ex, dir: await ex.readDirectory(createPublicClient({ chain: arbitrumSepolia, transport: http() })) };
             exploredAt = Date.now();
         }
         const { ex, dir } = explored;
-        const { EMBED_MODEL } = await import("./embed.js");
+        const { EMBED_MODEL } = await import("../core/embed.js");
         const qv = query?.trim() ? await vt.queryVector(query) : null;
         const apps = ex.rankApps(dir.apps, query, { qv, model: EMBED_MODEL }).map(ex.brief);
         return { apps, ranked_by: apps[0]?.ranked_by ?? null };

package/{consume → src/agent}/tools.js

@@ -11,8 +11,8 @@
 //
 // Pure functions, so `node tools.js` checks them with no browser and no network.
 
-import { bestPassage, cosine, lexScore, norm, zFloor } from "./rank.js";
-import { briefOf, collections, linkOf, subtitleOf, titleOf, typeOf, values } from "./roles.js";
+import { bestPassage, cosine, lexScore, norm, zFloor } from "../core/rank.js";
+import { briefOf, collections, linkOf, subtitleOf, titleOf, typeOf, values } from "../core/roles.js";
 
 /** Fields that are plumbing rather than content — never worth faceting or
  *  showing as "what this corpus holds". */
@@ -232,7 +232,7 @@ export function getRow(rows, id, roles) {
 
 // ── self-check: `node tools.js` — no browser, no network ────────────────────
 if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/tools.js")) {
-    const { rolesFrom } = await import("./roles.js");
+    const { rolesFrom } = await import("../core/roles.js");
     const row = (id, fields, vector) => ({
         id, owner: "0xa", ...fields,
         text: [fields.name, fields.desc].filter(Boolean).join(" "),

package/{consume → src/agent}/ui.js

@@ -504,7 +504,7 @@ export function stage({ picks = [], heading = "", note = "" } = {}) {
 <script>window.__ITEMS__ = ${json};${STAGE_JS}<\/script>`;
 }
 
-// ── self-check: `node consume/ui.js` ────────────────────────────────────────
+// ── self-check: `node src/agent/ui.js` ────────────────────────────────────────
 if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/ui.js")) {
     const roles = { measures: ["rating", "year", "runtime", "votes"] };
     const html = rankedList({

package/{consume → src/agent}/view-tools.js

@@ -16,12 +16,12 @@
 //
 // `get`/`similar`/`count` answer over what is loaded, and say so.
 
-import { configure, loadShard, trimView } from "./shard.js";
-import { rolesFrom, textOf } from "./roles.js";
+import { configure, loadShard, trimView } from "../core/shard.js";
+import { rolesFrom, textOf } from "../core/roles.js";
 import { browse, facet, getRow, neighbors, search } from "./tools.js";
-import { lexScore, rankDomains } from "./rank.js";
+import { lexScore, rankDomains } from "../core/rank.js";
 import { existsSync } from "node:fs";
-import { EMBED_MODEL, embedQueryDirect, warmDirect } from "./embed.js";
+import { EMBED_MODEL, embedQueryDirect, warmDirect } from "../core/embed.js";
 
 const ROUTE_TOP = 3;
 

package/{consume → src/agent}/x402.js

@@ -62,7 +62,7 @@ export async function payAndFetch(url, { privateKey, account, maxPrice, fetchImp
     return { status: paid.status, body, price: req.maxAmountRequired, receipt: receiptHeader ? JSON.parse(unb64(receiptHeader)) : null };
 }
 
-// ── self-check: `node consume/x402.js` — a stand-in seller that checks the signature ──
+// ── self-check: `node src/agent/x402.js` — a stand-in seller that checks the signature ──
 if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/x402.js")) {
     const { privateKeyToAccount, generatePrivateKey } = await import("viem/accounts");
     const { verifyTypedData } = await import("viem");

package/{consume → src/core}/ort-preload.js

@@ -9,7 +9,7 @@ import { dlopen } from "bun:ffi";
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 // build-bin.js puts the target's library here before it compiles.
-import lib from "../dist/ort/libonnxruntime.so.1" with { type: "file" };
+import lib from "../../dist/ort/libonnxruntime.so.1" with { type: "file" };
 
 try {
     const dir = `${homedir()}/.cache/fangorn-mcp/lib/${lib.split("/").pop()}`;   // bun names it by content hash

package/{consume → src/core}/rank.js

@@ -158,7 +158,7 @@ export function rankDomains(domains = [], q) {
         .sort((a, b) => (b.affinity ?? -Infinity) - (a.affinity ?? -Infinity));
 }
 
-// ── self-check: `node consume/rank.js` ──────────────────────────────────────
+// ── self-check: `node src/core/rank.js` ──────────────────────────────────────
 if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/rank.js")) {
     // Word boundaries: the bug this replaced ranked "intoxicated" for "cat".
     if (lexScore({ text: "intoxicated education" }, "cat") !== 0) throw new Error("substring matched — word boundaries lost");

package/{consume → src/core}/roles.js

@@ -366,7 +366,7 @@ export function actionsOf(row, roles) {
     }).filter((a) => a.locked.length || !a.missing.length);
 }
 
-// ── self-check: `node consume/roles.js` ─────────────────────────────────────
+// ── self-check: `node src/core/roles.js` ─────────────────────────────────────
 if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/roles.js")) {
     // The real places manifest's shape.
     const places = {

package/{consume → src/core}/shard.js

@@ -437,7 +437,7 @@ export async function suggestDomains(q, { url } = {}) {
     return rankDomains(domains, q);
 }
 
-// ── self-check: `node consume/shard.js` — no network, no view ────────────────
+// ── self-check: `node src/core/shard.js` — no network, no view ────────────────
 if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/shard.js")) {
     const { gzipSync } = await import("node:zlib");
     const warn = console.warn, info = console.info;

package/{consume → src/discover}/apps.js

@@ -30,7 +30,7 @@ function safeView(url) {
 }
 
 /** The SDK's FANGORN_APP_EXTENSION. Copied so this file needs no SDK;
- *  publish/agent-card.js's self-check fails if the two drift. */
+ *  src/agent/agent-card.js's self-check fails if the two drift. */
 export const APP_EXTENSION = "https://fangorn.network/a2a/app/v1";
 
 /** A verified card → an app entry. `views` is westmarch's param; the SDK does not read it. */
@@ -70,7 +70,7 @@ export async function listApps(fangorn, { fromBlock, toBlock } = {}) {
     return { apps, rejected };
 }
 
-// ── self-check: `node consume/apps.js` ──────────────────────────────────────
+// ── self-check: `node src/discover/apps.js` ──────────────────────────────────────
 if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/apps.js")) {
     const j = (x) => JSON.stringify(x, (_, v) => (typeof v === "bigint" ? `${v}n` : v));
     const eq = (a, b, m) => { if (j(a) !== j(b)) throw new Error(`${m}: ${j(a)} != ${j(b)}`); };

package/{consume → src/discover}/corpora.js

@@ -15,7 +15,7 @@
 // each and a person opens a handful; when a session holds enough of them to
 // matter, drop the least recently focused — the map is already keyed for it.
 
-import { trimView } from "./shard.js";
+import { trimView } from "../core/shard.js";
 
 /**
  * A set of open corpora, and the vocabulary for naming one.
@@ -188,7 +188,7 @@ export function follow(picks = [], corpora = [], { at = null } = {}) {
     return out;
 }
 
-// ── self-check: `node consume/corpora.js` ───────────────────────────────────
+// ── self-check: `node src/discover/corpora.js` ───────────────────────────────────
 if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/corpora.js")) {
     const s = session();
     const add = (view, name, n) => {

package/{consume → src/discover}/directory.js

@@ -22,8 +22,8 @@
 // still well under a second. Past that, the directory needs its own coverage
 // index, which is the same trick one level up.
 
-import { trimView } from "./shard.js";
-import { rankDomains, zFloor } from "./rank.js";
+import { trimView } from "../core/shard.js";
+import { rankDomains, zFloor } from "../core/rank.js";
 import { listApps } from "./apps.js";
 
 /** Catalog URL for a view base, tolerating either form the registry prints. */
@@ -167,7 +167,7 @@ export async function sourcesFromChain(fangorn, opts) {
     return { sources: apps.flatMap((a) => a.views.map((view) => ({ view, name: a.name, appId: a.appId }))), rejected };
 }
 
-// ── self-check: `node consume/directory.js` ─────────────────────────────────
+// ── self-check: `node src/discover/directory.js` ─────────────────────────────────
 if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/directory.js")) {
     const warn = console.warn; console.warn = () => {};
     const cov = (...vectors) => ({ dim: 2, sampled: 100, vectors, counts: vectors.map(() => 50) });

package/{consume → src/discover}/explore.js

@@ -8,26 +8,30 @@
 //   ERC-8004 identity `Registered`  the agent minted for the app
 //   ERC-8004 reputation             feedback count and average per agent
 //
-// Both registries answer the whole range in one `eth_getLogs` on Arbitrum
-// Sepolia (39 and ~1.5k logs today), so the page and the MCP tool read the same
-// chain the same way, and a new app shows up on the next read.
+// Both registries are scanned from their first event in 10M-block windows, in
+// parallel, so the page and the MCP tool read the same chain the same way, and
+// a new app shows up on the next read.
 //
 // `client` is a viem PublicClient (getLogs, readContract): passed in, so this
 // runs in a tab and in node, and the self-check needs no chain.
 //
-// ponytail: one getLogs per registry from block 0. An RPC that caps log ranges
-// will refuse it; window the scan then (the SDK's getLogsInWindows).
+// ponytail: windows grow with the chain (1 + 8 at block 316M, ~0.2s). Index
+// the logs somewhere if that ever gets slow.
 
 import { parseAbi, parseAbiItem } from "viem";
 import { APP_EXTENSION } from "./apps.js";
 import { survey, comparable } from "./directory.js";
-import { rankDomains, zFloor, lexScore } from "./rank.js";
+import { rankDomains, zFloor, lexScore } from "../core/rank.js";
 
 export const CHAIN = {
     chainId: 421614,
     appRegistry: "0x11d228c4774af3d9cae3b4b6874a12576a1a83ec",
     identity: "0x8004A818BFB912233c491871b3d84c89A494BD9e",
     reputation: "0x8004B663056A597Dffe9eCcC1965A193B7388713",
+    // Each registry's first event (2026-10-05): nothing to read before it.
+    // Scanning from 0 instead was 32 windows per registry, ~5s of a 7.7s load.
+    appRegistryFrom: 311_639_205n,
+    identityFrom: 241_557_787n,
     scan: (agentId) => `https://8004scan.io/agents/arbitrum-sepolia/${agentId}`,
 };
 
@@ -101,14 +105,28 @@ async function reputation(client, agentId, chain) {
     }
 }
 
+// The public Arbitrum Sepolia RPC refuses an address+event getLogs spanning more
+// than 10M blocks (from 2026-10; one call from 0 worked before).
+const LOG_WINDOW = 10_000_000n;
+
+async function getLogsSince(client, start, filter) {
+    const head = await client.getBlockNumber();
+    const windows = [];
+    for (let from = start; from <= head; from += LOG_WINDOW) {
+        const to = from + LOG_WINDOW - 1n < head ? from + LOG_WINDOW - 1n : head;
+        windows.push(client.getLogs({ ...filter, fromBlock: from, toBlock: to }));
+    }
+    return (await Promise.all(windows)).flat();   // in window order: oldest first still holds
+}
+
 /**
  * Every verified app, with its 8004 agent, reputation, and catalog.
  * Unverified apps are dropped, not listed; `dropped` says why, for debugging.
  */
 export async function readDirectory(client, { chain = CHAIN } = {}) {
     const [bindLogs, regLogs] = await Promise.all([
-        client.getLogs({ address: chain.appRegistry, event: APP_AGENT_CHANGED, fromBlock: 0n, toBlock: "latest" }),
-        client.getLogs({ address: chain.identity, event: REGISTERED, fromBlock: 0n, toBlock: "latest" }),
+        getLogsSince(client, chain.appRegistryFrom ?? 0n, { address: chain.appRegistry, event: APP_AGENT_CHANGED }),
+        getLogsSince(client, chain.identityFrom ?? 0n, { address: chain.identity, event: REGISTERED }),
     ]);
     const registered = regLogs.map((l) => ({ agentId: l.args.agentId, owner: l.args.owner, block: l.blockNumber }));
     const latest = new Map();   // logs come oldest first: the last write wins
@@ -131,9 +149,14 @@ export async function readDirectory(client, { chain = CHAIN } = {}) {
 
     const apps = await Promise.all(verified.map(async ({ appId, uri, block, card }) => {
         const p = card.capabilities.extensions.find((e) => e.uri === APP_EXTENSION).params;
-        const owner = await client.readContract({ address: chain.appRegistry, abi: APPS, functionName: "getAppOwner", args: [appId] }).catch(() => null);
-        const agentId = owner && pairAgent(registered, owner, block);
-        const { corpora, unreachable } = await survey((p.views ?? []).filter((v) => /^https:\/\//.test(v)));
+        const [[owner, agentId, rep], { corpora, unreachable }] = await Promise.all([
+            client.readContract({ address: chain.appRegistry, abi: APPS, functionName: "getAppOwner", args: [appId] }).catch(() => null)
+                .then(async (owner) => {
+                    const agentId = owner && pairAgent(registered, owner, block);
+                    return [owner, agentId, agentId == null ? null : await reputation(client, agentId, chain)];
+                }),
+            survey((p.views ?? []).filter((v) => /^https:\/\//.test(v))),
+        ]);
         const name = typeof card.name === "string" && card.name.trim() ? card.name.trim() : `App ${appId.slice(0, 10)}`;
         return {
             app: slug(name), name, description: typeof card.description === "string" ? card.description : "",
@@ -141,7 +164,7 @@ export async function readDirectory(client, { chain = CHAIN } = {}) {
             boundAt: Number(block), fromBlock: Number(p.fromBlock),
             tools: (card.skills ?? []).map((s) => s.id),
             agent: agentId == null ? null : { id: Number(agentId), scan: chain.scan(agentId) },
-            reputation: agentId == null ? null : await reputation(client, agentId, chain),
+            reputation: rep,
             // null, not 0, when no catalog answered: "0 records" would claim it was counted.
             rows: corpora.length ? corpora.reduce((n, c) => n + (c.rows || 0), 0) : null,
             unreachable: unreachable.length,
@@ -200,7 +223,7 @@ export function rankApps(apps, query, { qv = null, model = null } = {}) {
  *  domains, so an app reports how many, and which one matched. */
 export const brief = ({ domains, ...a }) => ({ ...a, domains: domains.length });
 
-// ── self-check: `node consume/explore.js` ──────────────────────────────────
+// ── self-check: `node src/discover/explore.js` ──────────────────────────────────
 if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/explore.js")) {
     const j = (x) => JSON.stringify(x, (_, v) => (typeof v === "bigint" ? `${v}n` : v));
     const eq = (a, b, m) => { if (j(a) !== j(b)) throw new Error(`${m}: ${j(a)} != ${j(b)}`); };

package/{publish → src/market}/cohort.js

@@ -246,7 +246,7 @@ export function readout(total, cohort, { minSupport = MIN_SUPPORT } = {}) {
     };
 }
 
-// ── self-check: `node publish/cohort.js` ──────────────────────────────────
+// ── self-check: `node src/market/cohort.js` ──────────────────────────────────
 if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/cohort.js")) {
     const vec = (a, b) => { const v = new Float32Array(STAT_DIM); v[0] = a; v[1] = b; return v; };
     const log = (n, seed) => Array.from({ length: n }, (_, i) => ({

package/{publish → src/market}/demand.js

@@ -45,7 +45,7 @@
 // says what was measured and what the publisher owns near it. Everything past
 // that is a model of a market that has run five simulated rounds.
 
-import { vocabulary, affinities } from "../consume/taste-doc.js";
+import { vocabulary, affinities } from "../taste/taste-doc.js";
 
 /** Matched reactions per reader below which a region is not drawing attention.
  *  0.5 = the median reader reacted to something here at least every other
@@ -382,7 +382,7 @@ export function brief(rep, { title = "demand" } = {}) {
     return L.join("\n");
 }
 
-// ── self-check: `node publish/demand.js` ────────────────────────────────────
+// ── self-check: `node src/market/demand.js` ────────────────────────────────────
 if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/demand.js")) {
     const { keypair, statistics, contribute, aggregate, readout } = await import("./cohort.js");
 

package/{publish → src/market}/reactions.js

@@ -42,7 +42,7 @@
 // Nothing is lost, because nobody buys row 47 of a stranger's reactions. A taste
 // corpus is bought WHOLE, and the question a buyer actually asks — "does this
 // reader have dense signal where I am training?" — is answered by the centroids
-// alone. That is already how `consume/directory.js` ranks a corpus nobody has
+// alone. That is already how `src/discover/directory.js` ranks a corpus nobody has
 // downloaded. Per-row vectors served no buyer and leaked the entire product.
 //
 // The centroids are themselves averages, so `k` is capped to keep at least
@@ -50,7 +50,7 @@
 // IS that reaction's vector under another name, which is the same leak wearing a
 // hat, and a reader with nine reactions is exactly who most needs this to hold.
 
-import { packVec } from "../consume/embed.js";
+import { packVec } from "../core/embed.js";
 import { lineage } from "./terms.js";
 
 // 32, not 8: on Kingsfoil the top 3 of 23 views held 92% of the true top 10 with 32
@@ -168,7 +168,7 @@ export function reactionCorpus(events = [], {
 
     // The split is applied HERE, to the rows themselves, not merely declared in
     // the manifest. Declaring it and shipping the fields anyway is the exact bug
-    // `consume/lint.js` calls "paywall names fields the free shard ships anyway",
+    // `src/publish/lint.js` calls "paywall names fields the free shard ships anyway",
     // and this file had it: it returned every field on every row and left the
     // withholding to a bake that does not run on this path.
     const wire = [], locked = [];
@@ -236,7 +236,7 @@ export function reactionCorpus(events = [], {
     return { manifest, rows: wire, locked, lineage: up, byCorpus: Object.fromEntries(byCorpus) };
 }
 
-// ── self-check: `node publish/reactions.js` ────────────────────────────────
+// ── self-check: `node src/market/reactions.js` ────────────────────────────────
 if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/reactions.js")) {
     const { splitPayment } = await import("./terms.js");
     const A = (n) => `0x${String(n).repeat(40).slice(0, 40)}`;

package/{publish → src/market}/settle.js

@@ -16,7 +16,7 @@ import { bytesToHex } from "viem";
 import {
     CHUNK_SIZE, NONCE_LEN, aadFor, chunkKey, deleteResource,
     getWorkerPubkey, pack, putChunk, unpack,
-} from "./envelope.js";
+} from "../publish/envelope.js";
 
 export { CHUNK_SIZE, aadFor, chunkKey, deleteResource, getWorkerPubkey };
 
@@ -64,7 +64,7 @@ export async function encryptAndUpload({ file, resourceId, workerUrl, uploadToke
     }
 }
 
-// ── self-check: `node publish/settle.js` — no network, no worker ─────────────
+// ── self-check: `node src/market/settle.js` — no network, no worker ─────────────
 //
 // It decrypts with bare AES-GCM rather than importing a buyer, because what is
 // under test here is the ENCRYPTOR: chunk addressing, the AAD index binding, the

package/{publish → src/market}/terms.js

@@ -136,7 +136,7 @@ export function splitPayment(amount, { terms, publisher, lineage: up = [] } = {}
  *  price anyone reads. */
 export const label = (base, currency = "USDC") => `${(Number(base) / 1e6).toFixed(2)} ${currency}`;
 
-// ── self-check: `node publish/terms.js` ────────────────────────────────────
+// ── self-check: `node src/market/terms.js` ────────────────────────────────────
 if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/terms.js")) {
     const A = "0x" + "a".repeat(40);   // app owner
     const P = "0x" + "b".repeat(40);   // publisher

package/{publish → src/publish}/cli.js

@@ -47,7 +47,7 @@ import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { basename, join, relative, resolve, sep } from "node:path";
 import { createPublicClient, createWalletClient, defineChain, http } from "viem";
 import { privateKeyToAccount } from "viem/accounts";
-import { encryptAndUpload } from "./settle.js";
+import { encryptAndUpload } from "../market/settle.js";
 import { resourceIdFor } from "./envelope.js";
 import { newUid, readManifest, writeManifest } from "./manifest.js";
 
@@ -299,7 +299,7 @@ async function main() {
     for (const [path, ptr] of Object.entries(sealed.published)) console.log(`  ${path}  ${ptr.resourceId}`);
 }
 
-// ── self-check: `node publish/cli.js --selfcheck` (offline) ──────────────────
+// ── self-check: `node src/publish/cli.js --selfcheck` (offline) ──────────────────
 
 if (flags.selfcheck) {
     const assert = (cond, msg) => { if (!cond) throw new Error(msg); };

package/{publish → src/publish}/envelope.js

@@ -150,7 +150,7 @@ export async function deleteResource({ workerUrl, uploadToken, resourceId, chunk
     return Math.max(1, chunks);
 }
 
-// ── self-check: `node publish/envelope.js` ───────────────────────────────────
+// ── self-check: `node src/publish/envelope.js` ───────────────────────────────────
 //
 // These vectors are PINNED to the values sond3r's own envelope.js produced before
 // this file was extracted from it, with ns = "sond3r". They are not a style test:

package/{publish → src/publish}/eval.ts

@@ -12,7 +12,7 @@
 // them. So: build a base view (main's recipe) and a candidate (the change) from the
 // same data, on the same machine, and run both through here. The exit code is the gate.
 //
-// Every check runs the reader's own code (consume/tools.js `search`, the same model),
+// Every check runs the reader's own code (src/agent/tools.js `search`, the same model),
 // so a score is what an agent calling fangorn-mcp would get, not what a test harness
 // with its own ranker would.
 //
@@ -56,7 +56,7 @@ import { EMBED_MODEL, embedQueryDirect } from "@fangorn-network/westmarch/embed"
 
 type Pred = { where?: Record<string, string>; match?: Record<string, string>; not?: Pred };
 type Check = { id: string; goal?: string } & (
-    | { kind?: "search"; q: string; k?: number; expect: Pred; min?: number }
+    | { kind?: "search"; q: string; k?: number; of?: Pred; expect: Pred; min?: number }
     | { kind: "count"; where?: Record<string, string>; expect?: Pred; min?: number; max?: number }
     | { kind: "records"; of?: Pred; expect: Pred; max_pct: number; hard?: boolean }
     | { kind: "coverage"; field: string; values: string[]; weights?: Record<string, number>; of?: Pred; min?: number });
@@ -107,7 +107,8 @@ async function grade(rows: Row[], roles: Roles, checks: Check[], qv: QueryVector
             out.push({ id: c.id, kind: "coverage", score, pass: score >= (c.min ?? 0), top: missing.slice(0, 10), ...goal });
         } else {
             const k = c.k ?? 5, ok = compile(c.expect);
-            const hits = search(rows, c.q, roles, { qv: await qv(c.q), limit: k }).map((h) => byId.get(h.id)!);
+            // `of` scopes the search to the rows a surface searches (a page tab, a tool's filter).
+            const hits = search(c.of ? rows.filter(compile(c.of)) : rows, c.q, roles, { qv: await qv(c.q), limit: k }).map((h) => byId.get(h.id)!);
             const score = round(hits.filter(ok).length / k);
             out.push({ id: c.id, kind: "search", score, pass: score >= (c.min ?? 0), top: hits.slice(0, 3).map((r) => titleOf(r, roles).slice(0, 90)), ...goal });
         }
@@ -276,6 +277,8 @@ async function selfcheck() {
     assert(r.wells.score === 0 && !r.wells.pass, "a count with nothing to reach fails (min defaults to 1)");
     assert(r.addresses.score === 25 && r.addresses.pass, `records is a percentage: ${r.addresses.score}`);
     const [scoped] = await grade(rows, roles, [{ id: "s", kind: "records", of: { where: { city: "Stevens Point" } }, expect: { match: { text: "Rd" } }, max_pct: 100 }], async () => null, 0);
+    const [sq] = await grade(rows, roles, [{ id: "sq", q: "rezoning", of: { where: { city: "Stevens Point" } }, expect: { match: { heading: "rezon" } }, k: 1 }], async () => null, 0);
+    assert(sq.score === 0 && !/Rezoning/.test(sq.top?.join() ?? ""), `\`of\` scopes a search check to its rows: ${JSON.stringify(sq)}`);
     assert(scoped.score === 50, `\`of\` narrows the rows a record check counts: ${scoped.score}`);
     assert(r["known@10"].score === 1, "every title finds its own row");
 

package/{consume → src/publish}/lint.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 // What will the index be able to do with what you baked?
 //
 // Every capability on the consumer side is paid for at bake time, and the bill
@@ -17,9 +18,9 @@
 // there are three real outcomes — the reader cannot find you, they find you and
 // cannot read you, or they read you and cannot go anywhere.
 
-import { configure, loadShard, resetShard, trimView } from "./shard.js";
-import { shapeOf } from "./ui.js";
-import { inSample, rolesFrom, textOf } from "./roles.js";
+import { configure, loadShard, resetShard, trimView } from "../core/shard.js";
+import { shapeOf } from "../agent/ui.js";
+import { inSample, rolesFrom, textOf } from "../core/roles.js";
 
 /** The model every corpus on this network is baked with. Cosine between two
  *  models' vectors is noise that still looks like a score, so a mismatch is not
@@ -305,7 +306,7 @@ export function format(r) {
     return out.join("\n");
 }
 
-// ── cli + self-check: `node consume/lint.js [viewUrl]` ─────────────────────
+// ── cli + self-check: `node src/publish/lint.js [viewUrl]` ─────────────────────
 if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/lint.js")) {
     const arg = process.argv.slice(2).find((a) => !a.startsWith("--"));
     if (arg) {

package/{publish → src/publish}/manifest.js

@@ -89,7 +89,7 @@ export function manifestFromTree(files, { defaultPrice = "1000", newUid: uid = n
     return out;
 }
 
-// ── self-check: `node publish/manifest.js` ───────────────────────────────────
+// ── self-check: `node src/publish/manifest.js` ───────────────────────────────────
 if (import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/manifest.js")) {
     const assert = (c, m) => { if (!c) throw new Error(m); };
 

package/{publish → src/publish}/ship.js

@@ -37,7 +37,7 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 const HERE = dirname(fileURLToPath(import.meta.url));
 const USDC = { "arbitrum-sepolia": "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d", arbitrum: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
                "base-sepolia": "0x036CbD53842c5426634e7929541eC2318f3dCF7e", base: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" };
-const STOCK = join(HERE, "../site/dist");
+const STOCK = join(HERE, "../../site/dist");
 const log = (s) => console.error(`[ship] ${s}`);
 
 // ── config ────────────────────────────────────────────────────────────────────
@@ -176,7 +176,7 @@ export async function ship(configPath, { crawl = true, deploy = true, dry = fals
 
     const [{ FangornConfig }, { createPublicClient, http }, { env }, view, card] = await Promise.all([
         import("@fangorn-network/sdk"), import("viem"),
-        import("@huggingface/transformers"), import("./view.js"), import("./agent-card.js"),
+        import("@huggingface/transformers"), import("./view.js"), import("../agent/agent-card.js"),
     ]);
     env.cacheDir = `${homedir()}/.cache/fangorn-mcp/models`;
     const fangorn = await view.readOnlyFangorn();
@@ -290,11 +290,11 @@ export async function ship(configPath, { crawl = true, deploy = true, dry = fals
     const media = Object.values(cfg.types).flatMap((t) => [t.role_map?.media ?? []].flat());
     const docHosts = [...new Set(live.flatMap((f) => media.map((m) => f[m])).filter((u) => typeof u === "string" && u.startsWith("https://"))
         .map((u) => { try { return new URL(u).hostname; } catch { return null; } }).filter(Boolean))].sort();
-    writeFileSync(join(site, "_worker.js"), readFileSync(join(HERE, "../site/worker.js"), "utf8")
+    writeFileSync(join(site, "_worker.js"), readFileSync(join(HERE, "../../site/worker.js"), "utf8")
         .replace(/\/\*CONFIG\*\/[\s\S]*?\/\*END\*\//, JSON.stringify({ docHosts, paid: sale })));
     log(`documents: shown inline from ${docHosts.length} source host(s)`);
     // The card lists the tools the page at `url` registers: the stock page's, or the app's own.
-    const { registerAgent } = await import(cfg.site.agent ? pathToFileURL(resolve(base, cfg.site.agent)).href : "../site/agent.js");
+    const { registerAgent } = await import(cfg.site.agent ? pathToFileURL(resolve(base, cfg.site.agent)).href : "../../site/agent.js");
     const agentCard = card.agentCard({
         name: cfg.name, description: cfg.description, url: `${url}/`, version: new Date().toISOString().slice(0, 10),
         tools: await card.captureTools(() => registerAgent({})), tags: cfg.tags,