@finchip.ai/foga 0.0.0-stage → 0.6.0-alpha.4

package/dist/doctor/semantic.js

@@ -0,0 +1,83 @@
+import { readJson } from "../util/fs.js";
+/**
+ * Which standards a genesis check exercises, by the dotted tokens of its name; several may apply. A token matches
+ * whole (`aid` does not match `unpaid`), so a name is attributed by what it names.
+ */
+const tok = (...words) => new RegExp(`(^|\\.)(${words.join("|")})(\\.|$)`);
+const RULES = [
+    { test: tok("kya", "scheme", "zk", "S_att", "S_cred", "S_pred", "nullifier", "epoch", "predicate", "attest"), ercs: ["8419"] },
+    { test: tok("aid", "anchor", "heartbeat", "document", "retire", "retired", "stale", "bind"), ercs: ["8434"] },
+    { test: /^A\.active|^Aprime\.active/, ercs: ["8434"] },
+    { test: tok("asf", "spec", "binding", "status", "suspend", "resume", "escape", "bypass", "derisk", "newrisk", "safety", "requirementId", "bindingId"), ercs: ["8468"] },
+    { test: tok("skill", "tamper", "commitment", "finch-extract-verify", "foga-probe"), ercs: ["8338"] },
+    { test: tok("tender", "submission", "submissions", "settle", "paid", "escrow", "completion", "copy", "answer", "fulfilment", "attribution", "withdraw", "accepted"), ercs: ["8414"] },
+    { test: tok("council", "ballot", "round", "nd", "gov", "judgment", "decide", "finalize", "appeal", "judges", "execute"), ercs: ["8436"] },
+    { test: tok("swarm", "roster", "join", "represent", "eligibility", "challenge", "charter", "members", "activate", "seat"), ercs: ["8447"] },
+    { test: tok("unit", "resolver", "receipt", "method", "measurement", "value"), ercs: ["8454"] },
+    { test: /^assertion\./, ercs: ["8454"] },
+    { test: tok("ard", "record", "backed", "adopted", "discovery"), ercs: ["8444"] },
+    { test: tok("dispute", "case", "ruling", "refund", "call1", "call2", "file", "finding", "service", "provider", "balances", "conforms", "released", "deposited", "charged", "held"), ercs: ["8471"] },
+    { test: tok("8004", "identity", "histories", "inherit"), ercs: ["8004"] },
+];
+/** Steps and the standards they are about, used when a check name says nothing. */
+const STEP_ERCS = {
+    T0: ["8419", "8468", "8436", "8471"],
+    T1: ["8004", "8434", "8468", "8419", "8444", "8454"],
+    T2: ["8338", "8444", "8454", "8434"],
+    T3: ["8414", "8444", "8338"],
+    T4: ["8447", "8436", "8414", "8454"],
+    T5: ["8436", "8447", "8414"],
+    T6: ["8471", "8436", "8338"],
+    T7: ["8468", "8414", "8434"],
+    T8: ["8454"],
+    T9: ["8434", "8004", "8444", "8338", "8419", "8447"],
+};
+export function ercsOf(check) {
+    const out = new Set();
+    for (const r of RULES)
+        if (r.test.test(check.name))
+            for (const e of r.ercs)
+                out.add(e);
+    if (out.size === 0)
+        for (const e of STEP_ERCS[check.step] ?? [])
+            out.add(e);
+    return [...out];
+}
+export function loadGenesisEvidence(path) {
+    const e = readJson(path);
+    if (e.schema !== "foga.genesis-evidence/1")
+        throw new Error(`${path} is not a genesis evidence file (schema ${e.schema})`);
+    return e;
+}
+/** Layer-5 verdicts per ERC from one evidence file. `ercs` are the standards present in the world. */
+export function semanticVerdicts(evidence, ercs) {
+    const per = new Map();
+    for (const e of ercs)
+        per.set(e, { checks: [] });
+    for (const c of evidence.checks)
+        for (const e of ercsOf(c))
+            per.get(e)?.checks.push(c);
+    const out = [];
+    for (const erc of ercs) {
+        const checks = per.get(erc).checks;
+        const skipped = checks.filter((c) => /^skipped:/.test(c.detail));
+        const effective = checks.filter((c) => !/^skipped:/.test(c.detail));
+        const failed = effective.filter((c) => !c.pass);
+        const steps = [...new Set(checks.map((c) => c.step))].sort();
+        let verdict = "NotTested";
+        if (effective.length > 0)
+            verdict = failed.length ? "Fail" : "Pass";
+        out.push({
+            erc,
+            verdict,
+            checks: checks.length,
+            passed: effective.length - failed.length,
+            failed: failed.length,
+            skipped: skipped.length,
+            steps,
+            failing: failed.map((c) => `${c.step} ${c.name}`),
+            detail: effective.length === 0 ? `no genesis check exercises ERC-${erc} in this evidence (until ${evidence.until})` : `${effective.length - failed.length}/${effective.length} checks pass over ${steps.join(", ")}${skipped.length ? `; ${skipped.length} skipped` : ""}${failed.length ? `; failing: ${failed.map((c) => `${c.step} ${c.name}`).join(", ")}` : ""}`,
+        });
+    }
+    return out;
+}

package/dist/genesis/extract.js

@@ -0,0 +1,64 @@
+import { readFileSync } from "node:fs";
+import { jcs, sha256Hex } from "../core/canonical.js";
+function normalize(kind, raw) {
+    const v = raw.trim();
+    if (!v)
+        return null;
+    if (kind === "amount") {
+        const n = v.replace(/,/g, "").match(/^-?\d+(\.\d+)?/);
+        return n ? n[0] : null;
+    }
+    if (kind === "date") {
+        const d = v.match(/^\d{4}-\d{2}-\d{2}/);
+        return d ? d[0] : null;
+    }
+    return v;
+}
+export function extractVerify(text, spec, packageHash) {
+    const lines = text.split(/\r?\n/);
+    const fields = {};
+    for (const f of spec.fields) {
+        const prefix = `${f.label}:`;
+        const idx = lines.findIndex((l) => l.startsWith(prefix));
+        if (idx < 0) {
+            fields[f.name] = { value: null, evidence: [] };
+            continue;
+        }
+        fields[f.name] = { value: normalize(f.kind, lines[idx].slice(prefix.length)), evidence: [{ line: idx + 1, quote: lines[idx].trim() }] };
+    }
+    const num = (name) => (fields[name]?.value === null || fields[name]?.value === undefined ? null : Number(fields[name].value));
+    const rules = [];
+    for (const r of spec.rules) {
+        if (r.id === "balance") {
+            const a = num("totalAssets");
+            const l = num("totalLiabilities");
+            const e = num("totalEquity");
+            if (a === null || l === null || e === null)
+                rules.push({ id: r.id, verdict: "unknown", note: "a term is missing" });
+            else {
+                const diff = Math.abs(a - (l + e));
+                const tol = Number(r.tolerance ?? "0");
+                rules.push({ id: r.id, verdict: diff <= tol ? "pass" : "fail", note: `${a} vs ${l} + ${e} (difference ${diff}, tolerance ${tol})` });
+            }
+        }
+        else if (r.id === "period") {
+            const p = fields.periodEnd?.value ?? null;
+            const d = fields.documentDate?.value ?? null;
+            if (!p || !d)
+                rules.push({ id: r.id, verdict: "unknown", note: "a date is missing" });
+            else
+                rules.push({ id: r.id, verdict: p <= d ? "pass" : "fail", note: `period end ${p}, document date ${d}` });
+        }
+        else {
+            rules.push({ id: r.id, verdict: "unknown", note: "rule not implemented by the deterministic path" });
+        }
+    }
+    return { schema: "finch.extract-verify/1", skill: { name: "finch-extract-verify", packageHash }, documentDigest: sha256Hex(text), fields, rules };
+}
+export function extractVerifyFile(documentPath, fieldsPath, packageHash) {
+    const text = readFileSync(documentPath, "utf8");
+    const spec = JSON.parse(readFileSync(fieldsPath, "utf8"));
+    const report = extractVerify(text, spec, packageHash);
+    const canonical = jcs(report);
+    return { report, canonical, resultHash: sha256Hex(canonical) };
+}

package/dist/genesis/funding.js

@@ -0,0 +1,126 @@
+import { formatEther, parseEther, parseUnits } from "ethers";
+import { CELLS, ROLE_ORDER } from "./roles.js";
+/**
+ * Who pays for what. Every role pays its own gas; the cells hold working capital (rewards they fund, deposits
+ * they make) and receive what they earn. W is the treasury of the genesis: it tops the other roles up to a floor
+ * before every step and gives each cell its capital at birth.
+ *
+ * On anvil the first ten accounts are pre-funded, so only the judges beyond them (J1-J3) and the cells need
+ * anything. On a public chain the floors come from the gas each role spent in the Sepolia run of 2026-11-01
+ * (docs/genesis.md, "Running on a public chain"), with a margin, at the fee the chain quotes when the step starts:
+ * a floor is a budget in gas, priced when it is checked, so a rising base fee raises the top-up rather than
+ * starving a role. A role is refilled to its floor once it has fallen below half of it. The quote is never taken
+ * below a floor of its own (FOGA_FEE_FLOOR_GWEI, default 0.1 gwei): a testnet quotes fractions of a wei when it is
+ * quiet, and a role funded at that price would be stranded by the first busy block.
+ */
+/**
+ * Gas a role spends over T0-T9 on a public chain, rounded up with a margin of about one half. Measured on Sepolia
+ * (deployments/sepolia.genesis.example.json, 203 operations, 475 M gas in all): W 131 M, G 0.8 M, owner.A 44.7 M,
+ * owner.B and owner.C 21.9 M each, operator.A 85.7 M, operator.B 103.5 M, operator.C 32.2 M, E 31.8 M, J1 0.8 M,
+ * J2 0.4 M, J3 nothing (the council decides with two of three). Sepolia's gas schedule prices the same operations
+ * 4.4 times higher than anvil's (a plain transfer 204,600 gas, code deposit about 1,500 gas per byte: deployments
+ * cost 6.5-7 times, calls 2-5 times), which is what a public chain costs from now on. The judges share one budget
+ * so that whichever two of them decide are funded.
+ */
+export const ROLE_GAS_BUDGET = {
+    W: 200000000n, // the genesis only; what `foga world deploy` spends before it is budgeted in src/world/deploy.ts (DEPLOY_GAS_PER_STEP)
+    G: 1250000n,
+    "owner.A": 67000000n,
+    "owner.B": 33000000n,
+    "owner.C": 33000000n,
+    "operator.A": 130000000n,
+    "operator.B": 156000000n,
+    "operator.C": 49000000n,
+    E: 48000000n,
+    J1: 1250000n,
+    J2: 1250000n,
+    J3: 1250000n,
+};
+/** Working capital of the cells: what they fund, deposit and keep (B funds 0.003 ETH of rewards over T3 and T7, C deposits 0.002). */
+export const CELL_CAPITAL = { local: parseEther("0.05"), public: parseEther("0.005") };
+export const SUCCESSOR_CAPITAL = { local: parseEther("0.01"), public: parseEther("0.001") };
+/** What W itself pays into tenders (the T4 reward and the T5 no-decision reward), on top of its gas. */
+export const W_VALUE_OUTLAY = parseEther("0.003");
+/** The least fee per gas a budget is priced at: FOGA_FEE_FLOOR_GWEI, default 0.1 gwei. */
+export function feeFloor() {
+    const v = process.env.FOGA_FEE_FLOOR_GWEI?.trim();
+    return parseUnits(v && /^\d+(\.\d+)?$/.test(v) ? v : "0.1", "gwei");
+}
+/** anvil pre-funds its first ten accounts with 10 000 ETH; the judges are beyond them. */
+const LOCAL_FLOORS = { J1: parseEther("1"), J2: parseEther("1"), J3: parseEther("1") };
+/** The fee per gas used to price a budget: the chain's current maxFeePerGas quote, at least the fee floor. */
+export async function quotePriceOf(provider) {
+    const fee = await provider.getFeeData();
+    const quoted = fee.maxFeePerGas ?? fee.gasPrice ?? 0n;
+    const floor = feeFloor();
+    return quoted > floor ? quoted : floor;
+}
+export function quotePrice(k) {
+    return quotePriceOf(k.world.provider);
+}
+export function floorOf(role, local, price) {
+    if (local)
+        return LOCAL_FLOORS[role] ?? 0n;
+    return ROLE_GAS_BUDGET[role] * price;
+}
+/**
+ * The gas an operator must still hold for its cell to take on work (the kernel's pre-commitment check): a quarter of
+ * the role's budget at the current price on a public chain; 0.01 ETH on anvil, where the operators are pre-funded.
+ */
+export async function operatorGasFloor(k, role) {
+    if (k.isLocalChain)
+        return parseEther("0.01");
+    return (ROLE_GAS_BUDGET[role] * (await quotePrice(k))) / 4n;
+}
+/** Balances against floors for every role but W, and W's own requirement. */
+export async function fundingPlan(k, price) {
+    const local = k.isLocalChain;
+    const p = price ?? (await quotePrice(k));
+    const lines = [];
+    for (const role of ROLE_ORDER) {
+        if (role === "W")
+            continue;
+        const address = k.address(role);
+        const balance = await k.balance(address);
+        const floor = floorOf(role, local, p);
+        // refilled to the floor once below half of it: a role that merely spent a little is not topped up at every step
+        lines.push({ role, address, balance, floor, topUp: balance < floor / 2n ? floor - balance : 0n });
+    }
+    const capital = local ? CELL_CAPITAL.local * BigInt(CELLS.length) + SUCCESSOR_CAPITAL.local : CELL_CAPITAL.public * BigInt(CELLS.length) + SUCCESSOR_CAPITAL.public;
+    const own = local ? 0n : ROLE_GAS_BUDGET.W * p + W_VALUE_OUTLAY;
+    const needW = lines.reduce((a, l) => a + l.topUp, 0n) + capital + own;
+    return { price: p, lines, needW, balanceW: await k.balance(k.address("W")) };
+}
+/**
+ * Before a step: W tops up every role that has fallen below its floor. Keyed per step and role, so a run that
+ * resumes finds the transfers it made and a role that stayed funded costs nothing. Fails before any transfer when W
+ * itself cannot cover the step, naming the shortfall.
+ */
+export async function fundRoles(k, step, log) {
+    // facts hold bigints as decimal strings: a resumed run reads the price back as a string
+    const price = BigInt(await k.memo(`${step}.fund.price`, async () => (await quotePrice(k)).toString()));
+    const plan = await fundingPlan(k, price);
+    const due = plan.lines.filter((l) => l.topUp > 0n || k.store.get(`${step}.fund.${l.role}`)?.status === "confirmed");
+    if (!due.length)
+        return [];
+    const total = due.reduce((a, l) => a + l.topUp, 0n);
+    if (plan.balanceW < total) {
+        throw new Error(`W ${k.address("W")} holds ${formatEther(plan.balanceW)} ETH but ${step} needs ${formatEther(total)} ETH of top-ups at ${Number(price) / 1e9} gwei (${due.map((l) => `${l.role} ${formatEther(l.topUp)}`).join(", ")}). Fund W and run again; \`foga genesis preflight\` prints the full plan.`);
+    }
+    for (const l of due) {
+        // the amount is fixed the first time (a resumed run must rebuild the same transfer), so a replayed row costs nothing new
+        const amount = await k.memo(`${step}.fund.${l.role}.amount`, () => l.topUp.toString());
+        if (BigInt(amount) === 0n)
+            continue;
+        await k.transfer(`${step}.fund.${l.role}`, "W", l.address, BigInt(amount));
+        log(`  fund: W -> ${l.role} ${formatEther(BigInt(amount))} ETH (floor ${formatEther(l.floor)} at ${Number(price) / 1e9} gwei)`);
+    }
+    return due;
+}
+export function formatPlan(plan, local) {
+    const out = [`fee per gas used for the floors: ${Number(plan.price) / 1e9} gwei${local ? " (local chain: fixed floors)" : plan.price === feeFloor() ? ` (the floor, FOGA_FEE_FLOOR_GWEI; the chain quotes less)` : " (the chain's quote)"}`];
+    for (const l of plan.lines)
+        out.push(`  ${l.role.padEnd(11)} ${l.address}  balance ${formatEther(l.balance).padStart(10)}  floor ${formatEther(l.floor).padStart(10)}  ${l.topUp > 0n ? `top-up ${formatEther(l.topUp)}` : "ok"}`);
+    out.push(`  W needs ${formatEther(plan.needW)} ETH for the top-ups, the cells' capital (${formatEther(local ? CELL_CAPITAL.local : CELL_CAPITAL.public)} each) and its own budget; it holds ${formatEther(plan.balanceW)} ETH${plan.balanceW < plan.needW ? ` — short by ${formatEther(plan.needW - plan.balanceW)} ETH` : ""}`);
+    return out;
+}

package/dist/genesis/operator-scope.js

@@ -0,0 +1,90 @@
+import { Interface } from "ethers";
+import { ERC8004_ABI } from "../core/erc8004.js";
+export const SCOPE_GROUPS = {
+    identity: [
+        { contract: "identity8004", fn: "register(string)", abi: ERC8004_ABI },
+        { contract: "identity8004", fn: "setAgentURI(uint256,string)", abi: ERC8004_ABI },
+        { contract: "8434/AIDRegistry", fn: "bind(address,uint256)" },
+        { contract: "8434/AIDRegistry", fn: "heartbeat()" },
+        { contract: "8434/AIDRegistry", fn: "setDocumentURI(string,bytes32)" },
+        { contract: "8434/AIDRegistry", fn: "setLivenessWindow(uint64)" },
+        { contract: "8434/AIDRegistry", fn: "retire(address)" },
+        { contract: "8444/ARDOnchainRegistry", fn: "register(bytes32,address,uint256,bytes32,string,string)" },
+        { contract: "8444/ARDOnchainRegistry", fn: "updateDescriptor(bytes32,bytes32,string,string)" },
+        { contract: "8454/AUFUnitRegistry", fn: "registerUnit(address,bytes32,string,(uint256,uint32)[])" },
+        { contract: "8447/ERC8004Eligibility", fn: "declareAgent(uint256)" },
+    ],
+    standing: [{ contract: "8419/KYARegistry", fn: "attestWithProof((bytes32,bytes),bytes32,bytes,bytes,string)" }],
+    "skills-provider": [
+        { contract: "8338/SkillToken", fn: "mintSkill(address,address,bytes32,bytes32,string)" },
+        { contract: "8338/SkillToken", fn: "updateSkill(uint256,bytes32,bytes32)" },
+    ],
+    labour: [
+        { contract: "8414/TaskToken", fn: "submitFulfillment(uint256,bytes32,string)" },
+        { contract: "8414/TaskToken", fn: "settleFulfillment(uint256,uint256,bytes)" },
+        { contract: "8414/TaskToken", fn: "withdrawCredit" },
+    ],
+    demander: [
+        { contract: "8414/TaskToken", fn: "mintTask" },
+        { contract: "8414/TaskToken", fn: "fundTask(uint256,uint256)" },
+        { contract: "8414/TaskToken", fn: "reclaimEscrow" },
+        { contract: "8414/HashlockVerifier", fn: "commitAnswer(address,uint256,bytes32)" },
+    ],
+    "organization-member": [
+        { contract: "8447/SwarmRegistry", fn: "join(bytes32,bytes32,bytes32)" },
+        { contract: "8447/SwarmRegistry", fn: "applyToJoin" },
+        { contract: "8447/SwarmRegistry", fn: "leave" },
+        { contract: "8436/ACDFRegistry", fn: "castBallot(bytes32,uint32,uint32,bool)" },
+    ],
+    "organization-coordinator": [
+        { contract: "8447/SwarmRegistry", fn: "form" },
+        { contract: "8447/SwarmRegistry", fn: "setAccount(bytes32,address)" },
+        // the swarm's account and the decision adapter are deployed in T4 and opened to the coordinator then (dynamic entries)
+    ],
+    "service-provider": [
+        { contract: "8471/ADRFServiceEscrow", fn: "deliver(uint256,bytes32)" },
+        { contract: "8471/ADRFServiceEscrow", fn: "settle(uint256)" },
+        { contract: "8471/ADRFServiceEscrow", fn: "withdrawBalance(uint256)" },
+    ],
+    "service-client": [
+        { contract: "8471/ADRFServiceEscrow", fn: "deposit()" },
+        { contract: "8471/ADRFServiceEscrow", fn: "openCall(address,uint256,bytes32,bytes32,uint64)" },
+        { contract: "8471/ADRFServiceEscrow", fn: "withdrawBalance(uint256)" },
+        { contract: "8471/ADRFServiceEscrow", fn: "enact(bytes32,bytes32)" },
+        { contract: "8471/ADRFDisputeRegistry", fn: "file", iface: "ai-dispute-resolution:IADRFDisputeRegistry" },
+    ],
+};
+/** The groups each genesis cell plays. A-prime (T9) takes the successor's groups: identity and what it inherits by adoption. */
+export const CELL_GROUPS = {
+    A: ["identity", "standing", "skills-provider", "labour", "organization-member", "service-provider"],
+    B: ["identity", "demander", "organization-coordinator", "organization-member"],
+    C: ["identity", "organization-member", "service-client"],
+    "A-prime": ["identity", "skills-provider", "labour", "service-provider"],
+};
+/** Resolve groups to (target, selector) pairs on this world; the backing AID registry mirrors the primary one's entries. */
+export function operatorScope(k, groups) {
+    const out = { targets: [], selectors: [], names: [] };
+    const seen = new Set();
+    const add = (target, selector, name) => {
+        const id = `${target.toLowerCase()}:${selector}`;
+        if (seen.has(id))
+            return;
+        seen.add(id);
+        out.targets.push(target);
+        out.selectors.push(selector);
+        out.names.push(name);
+    };
+    for (const group of groups) {
+        for (const e of SCOPE_GROUPS[group]) {
+            const target = k.world.address(e.contract);
+            const iface = e.abi ? new Interface(e.abi) : e.iface ? k.world.ifaceOf(e.iface) : k.world.iface(e.contract);
+            const f = iface.getFunction(e.fn);
+            if (!f)
+                throw new Error(`operator scope: ${e.contract} has no function ${e.fn}`);
+            add(target, f.selector, `${e.contract}.${e.fn}`);
+            if (e.contract === "8434/AIDRegistry" && k.aid.backing)
+                add(k.aid.backing.address, f.selector, `${k.aid.backing.id}.${e.fn}`);
+        }
+    }
+    return out;
+}

package/dist/genesis/preflight.js

@@ -0,0 +1,54 @@
+import { formatEther, getAddress } from "ethers";
+import { readJson } from "../util/fs.js";
+import { Kernel } from "../kernel/kernel.js";
+import { formatPlan, fundingPlan } from "./funding.js";
+import { ROLE_ORDER, roleKeys } from "./roles.js";
+import { LOCAL_TIMING, PUBLIC_TIMING, LIVENESS_DEMO_WINDOW } from "./scenario.js";
+import { predicateAvailability, zkAvailability } from "./zk.js";
+/**
+ * `foga genesis preflight`: everything a run on a public chain needs, checked before the first transaction — the
+ * RPC and its chain, the twelve keys, every role's balance against its floor and what W must hold, the escrow's
+ * admin, the proving material, and how long the waits will take. Nothing is sent. Returns the problems found.
+ */
+export async function preflight(opts) {
+    const problems = [];
+    const say = opts.log;
+    const world = readJson(opts.worldPath);
+    if (world.schema !== "foga.world/1")
+        throw new Error(`${opts.worldPath} is not a deployed world file (run foga world deploy first)`);
+    const keys = roleKeys(world);
+    const k = await Kernel.open({ worldPath: opts.worldPath, rpc: opts.rpc, bundlePath: opts.bundlePath, storePath: ":memory:", keys });
+    try {
+        const net = await k.world.provider.getNetwork();
+        const block = await k.world.provider.getBlock("latest");
+        say(`world ${world.worldId} (${world.network}, chain ${world.chainId}, ${world.mode}) via ${opts.rpc}: chain ${net.chainId}, block ${block?.number} at ${new Date(Number(block?.timestamp) * 1000).toISOString()}`);
+        say("roles:");
+        for (const role of ROLE_ORDER)
+            say(`  ${role.padEnd(11)} ${k.address(role)}`);
+        const plan = await fundingPlan(k);
+        say("funding:");
+        for (const line of formatPlan(plan, k.isLocalChain))
+            say(line);
+        if (plan.balanceW < plan.needW)
+            problems.push(`W ${k.address("W")} is short by ${formatEther(plan.needW - plan.balanceW)} ETH (holds ${formatEther(plan.balanceW)}, needs ${formatEther(plan.needW)} at ${Number(plan.price) / 1e9} gwei)`);
+        const admin = await k.adrf.escrow().admin();
+        const adminOk = getAddress(admin) === getAddress(k.address("W"));
+        say(`escrow: ${k.adrf.escrowAddress} administered by ${admin}${adminOk ? " (W)" : " (NOT W)"}`);
+        if (!adminOk)
+            problems.push(`the world's ADRFServiceEscrow is administered by ${admin}, not by W: deploy the world with W's key`);
+        say(`AID: primary registry ${k.aid.address}${k.aid.backing ? `; backing registry ${k.aid.backing.address} (${k.aid.backing.id}): cells bind, heartbeat and retire in both` : " (no backing registry)"}`);
+        const defaultWindow = await k.aid.defaultLivenessWindow();
+        say(`  default liveness window ${defaultWindow} s; T7 shortens A's window to ${LIVENESS_DEMO_WINDOW} s and waits for it`);
+        const zk = zkAvailability();
+        const pred = predicateAvailability();
+        say(`zk: credential path ${zk.ok ? "available" : "not available (" + zk.missing.join("; ") + ")"}; predicate path ${pred.ok ? "available" : "not available (" + pred.missing.join("; ") + ")"}`);
+        const t = k.isLocalChain ? LOCAL_TIMING : PUBLIC_TIMING;
+        const waits = t.appealWindow + t.councilWindow + t.noDecisionJudgmentWindow + t.appealWindow + t.service.reviewWindow + t.service.disputePeriod + LIVENESS_DEMO_WINDOW;
+        say(`timing: ${k.isLocalChain ? "local profile (the clock is moved)" : `public profile: about ${Math.round(waits / 60)} minutes of waiting over T5-T7 (council ${t.councilWindow} s, appeal ${t.appealWindow} s, judgment ${t.noDecisionJudgmentWindow} s, review ${t.service.reviewWindow} s, dispute period ${t.service.disputePeriod} s), plus one block per operation (about 190 operations)`}`);
+    }
+    finally {
+        k.close();
+        k.world.provider.destroy();
+    }
+    return problems;
+}

package/dist/genesis/probe.js

@@ -0,0 +1,164 @@
+import { Contract, getAddress } from "ethers";
+import { AIDStateName } from "../core/aid.js";
+import { ReasonName, VerdictName, accountSubjectKey } from "../core/asf.js";
+import { accountRef, jcs } from "../core/canonical.js";
+import { ERC8004_ABI } from "../core/erc8004.js";
+import { accountSubject } from "../core/kya.js";
+const ZERO = "0x0000000000000000000000000000000000000000";
+/**
+ * The `foga-probe` skill: eleven sections (ERC-8004 plus the ten), every read pinned to `input.block`, every
+ * value rendered so that JCS of the report is byte-stable (numbers as decimal strings, addresses lower-case).
+ */
+export async function runProbe(world, input) {
+    const subject = getAddress(input.subject);
+    const low = subject.toLowerCase();
+    const tag = input.block;
+    const block = await world.provider.getBlock(input.block);
+    if (!block)
+        throw new Error(`block ${input.block} not found`);
+    const at = { blockTag: tag };
+    const fromBlock = input.lookback === undefined ? 0 : Math.max(0, input.block - input.lookback);
+    const section = async (fn) => {
+        try {
+            return await fn();
+        }
+        catch {
+            return null;
+        }
+    };
+    const aid = world.contract("8434/AIDRegistry");
+    const checks = {};
+    checks.erc8434 = await section(async () => {
+        const state = Number(await aid.state(subject, at));
+        const b = await aid.bindingOf(subject, at);
+        const doc = await aid.documentURI(subject, at);
+        return {
+            state: AIDStateName[state],
+            registry: String(b.registry).toLowerCase(),
+            agentId: String(b.agentId),
+            boundAt: String(b.boundAt),
+            lastSeen: String(await aid.lastSeen(subject, at)),
+            documentDigest: String(doc.digest ?? doc[1]),
+        };
+    });
+    checks.erc8004 = await section(async () => {
+        const b = await aid.bindingOf(subject, at);
+        const registry = String(b.registry);
+        if (registry === ZERO)
+            return { bound: false };
+        const identity = new Contract(registry, ERC8004_ABI, world.provider);
+        const agentId = BigInt(b.agentId);
+        return {
+            bound: true,
+            registry: registry.toLowerCase(),
+            agentId: agentId.toString(),
+            owner: String(await identity.ownerOf(agentId, at)).toLowerCase(),
+            agentURI: String(await identity.tokenURI(agentId, at)),
+        };
+    });
+    checks.erc8419 = await section(async () => {
+        const kya = world.contract("8419/KYARegistry");
+        const issuers = input.kya.issuers.map((a) => getAddress(a));
+        const r = await kya.resolve(accountSubject(world.chainId, subject), input.kya.schemeId, issuers, at);
+        return {
+            schemeId: input.kya.schemeId,
+            issuers: issuers.map((a) => a.toLowerCase()),
+            level: String(r.level ?? r[0]),
+            expiresAt: String(r.expiresAt ?? r[1]),
+            assertionId: String(r.assertionId ?? r[2]),
+        };
+    });
+    checks.erc8468 = await section(async () => {
+        const bindings = world.contract("8468/ASFBindingRegistry");
+        const count = Number(await bindings.countBySubject(accountSubjectKey(world.chainId, subject), subject, at));
+        const out = { bindingsAsSubject: String(count) };
+        try {
+            const cell = world.at("foga:FogaCellAccount", subject);
+            const s = await cell.status(at);
+            out.status = { verdict: VerdictName[Number(s[0])], reasons: Array.from(s[1], (x) => ReasonName[Number(x)]), restrictions: Array.from(s[2], (x) => String(x)) };
+        }
+        catch {
+            out.status = null;
+        }
+        return out;
+    });
+    checks.erc8444 = await section(async () => {
+        const ard = world.contract("8444/ARDOnchainRegistry");
+        const recordId = String(await ard.recordIdOf(subject, 0n, at));
+        const rec = await ard.recordOf(recordId, at);
+        const status = Number(rec.status);
+        if (status === 0)
+            return { agentRecord: null };
+        return {
+            agentRecord: { recordId, status: String(status), descriptorHash: String(rec.descriptorHash), urn: String(rec.urn), backed: Boolean(await ard.backed(recordId, at)) },
+        };
+    });
+    checks.erc8454 = await section(async () => {
+        const units = world.contract("8454/AUFUnitRegistry");
+        const logs = await units.queryFilter(units.filters.UnitRegistered(null, subject), fromBlock, input.block);
+        return { unitsControlled: logs.map((l) => String(l.args.unitId)) };
+    });
+    checks.erc8338 = await section(async () => {
+        const skills = world.contract("8338/SkillToken");
+        const held = String(await skills.balanceOf(subject, at));
+        const received = await skills.queryFilter(skills.filters.Transfer(null, subject), fromBlock, input.block);
+        const ids = new Set();
+        for (const l of received)
+            ids.add(String(l.args.tokenId));
+        const tokens = [];
+        for (const id of [...ids].sort((a, b) => (BigInt(a) < BigInt(b) ? -1 : 1))) {
+            try {
+                if (String(await skills.ownerOf(BigInt(id), at)).toLowerCase() !== low)
+                    continue;
+                const b = await skills.skillOf(BigInt(id), at);
+                tokens.push({ tokenId: id, packageHash: String(b.packageHash), version: String(b.version) });
+            }
+            catch {
+                /* burned or absent at that block */
+            }
+        }
+        return { held, tokens };
+    });
+    checks.erc8414 = await section(async () => {
+        const tasks = world.contract("8414/TaskToken");
+        const held = String(await tasks.balanceOf(subject, at));
+        const submitted = await tasks.queryFilter(tasks.filters.FulfillmentSubmitted(null, null, subject), fromBlock, input.block);
+        const accepted = await tasks.queryFilter(tasks.filters.FulfillmentAccepted(null, null, subject), fromBlock, input.block);
+        return { held, submissions: String(submitted.length), accepted: String(accepted.length) };
+    });
+    checks.erc8447 = await section(async () => {
+        const swarms = world.contract("8447/SwarmRegistry");
+        const activated = await swarms.queryFilter(swarms.filters.MemberActivated(null, subject), fromBlock, input.block);
+        const ids = [...new Set(activated.map((l) => String(l.args.swarmId)))].sort();
+        const memberships = [];
+        for (const swarmId of ids)
+            memberships.push({ swarmId, status: String(await swarms.memberStatus(swarmId, subject, at)) });
+        return { memberships };
+    });
+    checks.erc8436 = await section(async () => {
+        const acdf = world.contract("8436/ACDFRegistry");
+        const filed = await acdf.queryFilter(acdf.filters.IssueFiled(null, null, null, subject), fromBlock, input.block);
+        return { issuesFiled: String(filed.length) };
+    });
+    checks.erc8471 = await section(async () => {
+        const adrf = world.contract("8471/ADRFDisputeRegistry");
+        const filed = await adrf.queryFilter(adrf.filters.CaseFiled(), fromBlock, input.block);
+        let asParty = 0;
+        for (const l of filed) {
+            if (String(l.args.claimant).toLowerCase() === low || String(l.args.respondent).toLowerCase() === low)
+                asParty++;
+        }
+        return { casesAsParty: String(asParty) };
+    });
+    const ordered = {};
+    for (const k of ["erc8004", "erc8434", "erc8419", "erc8468", "erc8444", "erc8454", "erc8338", "erc8414", "erc8447", "erc8436", "erc8471"])
+        ordered[k] = checks[k] ?? null;
+    const report = {
+        schema: "foga.probe/1",
+        skill: "foga-probe",
+        world: { worldId: world.file.worldId, chainId: world.chainId, block: input.block, blockHash: block.hash },
+        subject: accountRef(world.chainId, subject),
+        checks: ordered,
+    };
+    return { report, answer: jcs(report) };
+}