@fangorn-network/westmarch 0.0.10-dev → 0.0.12-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}/embed.js

@@ -13,6 +13,11 @@
 
 const MODEL = "nomic-ai/nomic-embed-text-v1.5";
 const DIM = 256;
+// The document side's precision. q8 everywhere by default (the browser's queries are q8).
+// WESTMARCH_EMBED_DTYPE=fp16 is a different encoder (~0.96 cosine to q8): a view records it
+// and refuses to mix the two (view.js), so switching an app is one --rebake.
+const DTYPE = globalThis.process?.env?.WESTMARCH_EMBED_DTYPE ?? "q8";
+export const EMBED_DTYPE = DTYPE;
 
 // Stamped onto every vector a publisher commits. Vectors from different models
 // (or dims) are not comparable — cosine between them is noise, and silently so.
@@ -25,10 +30,11 @@ let _extractor = null;
 const extractor = () => (_extractor ??= (async () => {
     const { pipeline } = await import("@huggingface/transformers");
     // WESTMARCH_EMBED_DEVICE=cuda puts the publisher's document side on a GPU (Node only; needs
-    // onnxruntime-node's CUDA binaries). Still q8 at batch 1, so still the same encoder: its
-    // vectors agree with CPU q8 to ~0.99, closer than the browser's WASM q8 queries (~0.98).
+    // onnxruntime-node's CUDA binaries and the matching CUDA runtime, cuBLAS, cuRAND and cuDNN on
+    // LD_LIBRARY_PATH). q8's integer ops do not run on CUDA, so q8 there is slower than on CPU:
+    // pair it with WESTMARCH_EMBED_DTYPE=fp16, which is ~4x faster than CPU q8, batched.
     const device = globalThis.process?.env?.WESTMARCH_EMBED_DEVICE;
-    return pipeline("feature-extraction", MODEL, { dtype: "q8", ...(device && { device }) });
+    return pipeline("feature-extraction", MODEL, { dtype: DTYPE, ...(device && { device }) });
 })());
 
 /** Standardize over the full vector, slice to `dim`, L2-normalize the slice. */
@@ -59,11 +65,30 @@ export async function embedQueryDirect(text) {
     return matryoshka(output.data);
 }
 
-/** One document, in-process. The batch loop stays with the caller — see embedDocuments. */
-export async function embedDocumentDirect(text) {
-    const ex = await extractor();
-    const output = await ex(`search_document: ${text}`, { pooling: "mean", normalize: false });
-    return matryoshka(output.data);
+/** One document, in-process. Calls made together are embedded as one batch (a GPU's
+ *  speed); q8 stays at batch 1, since batching moves its activation quantization. */
+export function embedDocumentDirect(text) {
+    return new Promise((resolve, reject) => {
+        pending.push({ text, resolve, reject });
+        if (pending.length === 1) setTimeout(flushDocuments, 0);
+    });
+}
+const BATCH = DTYPE === "q8" ? 1 : 32;
+let pending = [];
+async function flushDocuments() {
+    const all = pending;
+    pending = [];
+    try {
+        const ex = await extractor();
+        for (let i = 0; i < all.length; i += BATCH) {
+            const part = all.slice(i, i + BATCH);
+            const output = await ex(part.map((p) => `search_document: ${p.text}`), { pooling: "mean", normalize: false });
+            const d = output.dims.at(-1);
+            part.forEach((p, j) => p.resolve(matryoshka(output.data.slice(j * d, (j + 1) * d))));
+        }
+    } catch (e) {
+        for (const p of all) p.reject(e);
+    }
 }
 
 /** Load the model in-process, and settle when it is actually ready. */

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,54 +105,78 @@ 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.
+ *
+ * `onUpdate({ apps, pending })`, if given, is called once the bindings are read
+ * and again as each app lands or drops, so a page can show apps as they arrive.
+ * `pending` counts the bound apps not yet settled.
  */
-export async function readDirectory(client, { chain = CHAIN } = {}) {
+export async function readDirectory(client, { chain = CHAIN, onUpdate = () => {} } = {}) {
     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
     for (const l of bindLogs) latest.set(l.args.app_id, { uri: l.args.agent_uri, block: l.blockNumber });
+    const bound = [...latest].filter(([, { uri }]) => uri);   // an empty uri is unbound on purpose
 
-    // Two passes: verify every card (small), then read catalogs (Quorum's is
-    // 1.7 MB, Kingsfoil has 23). Only a card failure drops an app; an owner or
-    // catalog that fails leaves it listed with less to say about it.
-    const dropped = [];
-    const verified = (await Promise.all([...latest].map(async ([appId, { uri, block }]) => {
-        if (!uri) return null;   // unbound on purpose
+    // One pipeline per app, so the quick ones need not wait on Quorum's 1.7 MB
+    // catalog. Only a card failure drops an app; an owner or catalog that fails
+    // leaves it listed with less to say about it.
+    const apps = [], dropped = [];
+    let pending = bound.length;
+    const settle = () => { pending--; apps.sort((a, b) => a.name.localeCompare(b.name)); onUpdate({ apps: [...apps], pending }); };
+    onUpdate({ apps: [], pending });
+    await Promise.all(bound.map(async ([appId, { uri, block }]) => {
+        let card;
         try {
             if (!/^https:\/\//.test(uri)) throw new Error("card is not https");
-            const card = await json(uri);
+            card = await json(uri);
             const why = verifyCard(card, appId, chain);
             if (why) throw new Error(why);
-            return { appId, uri, block, card };
-        } catch (e) { dropped.push({ card: uri, why: e?.message ?? String(e) }); return null; }
-    }))).filter(Boolean);
+        } catch (e) { dropped.push({ card: uri, why: e?.message ?? String(e) }); return settle(); }
 
-    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 {
+        apps.push({
             app: slug(name), name, description: typeof card.description === "string" ? card.description : "",
             site: https(card.url), card: uri, appId, owner,
             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,
             domains: corpora.map((c) => ({ name: c.domain, description: c.description, rows: c.rows, coverage: c.coverage, model: c.model })),
-        };
+        });
+        settle();
     }));
-    apps.sort((a, b) => a.name.localeCompare(b.name));
     return { apps, dropped };
 }
 
@@ -200,7 +228,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.
 //