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

package/dist/genesis/t8.js

@@ -0,0 +1,189 @@
+import { getAddress } from "ethers";
+import { accountRef, dataUriJcs, keccakJcs } from "../core/canonical.js";
+import { AssertionKind, METHOD_KIND, checkReceipt, observationPayload, realizedNetCashFlowMethod, receiptHash, receiptUri, totals } from "../core/measure.js";
+/**
+ * T8 — value, as measured: realized net cash flow receipts (ERC-8454 observation profile), asserted by E, an
+ * independent measurer, and checked by a deterministic resolver.
+ *  (1) E registers the method descriptor foga.realized-net-cash-flow/1 once.
+ *  (2) The receipt for cell A's unit over T3-T7: the tender rewards and the released escrow settlement that
+ *      reached A's account are counted; the refunded call and the operator key's own payout are shown and
+ *      excluded; the cost is the gas A's keys paid for the account's operations; model fees are missing, not zero.
+ *  (3) The receipt for the swarm unit over T4-T5: the two tender payouts to the swarm account; the members' own
+ *      accounts are outside the boundary, and so is the gas their keys paid.
+ *  (4) The resolver recomputes both from the chain and passes them; a receipt that counts the swarm's tender for
+ *      A's unit fails the boundary and the double-count rules; a receipt citing an unregistered method is refused.
+ * No field of a receipt states a value.
+ */
+export async function t8(g) {
+    const k = g.kernel;
+    const E = "E";
+    const A = g.cell("A");
+    const chainId = g.chainId;
+    const method = realizedNetCashFlowMethod();
+    const methodHash = keccakJcs(method);
+    const unitA = BigInt(k.requireFact("T1.A.unitId"));
+    const unitSwarm = BigInt(k.requireFact("T4.unitId"));
+    const swarmAccount = k.requireFact("T4.swarmAccount");
+    const escrow = k.adrf.escrowAddress;
+    const tenders = k.tenders.address;
+    // --- (1) the method, registered once by E
+    const existing = await k.units.descriptorOf(methodHash);
+    if (!existing)
+        await k.call("T8.E.method.register", E, k.units.assertionRegistryAddress, k.units.assertions().interface, "registerDescriptor", [methodHash, METHOD_KIND, dataUriJcs(method)]);
+    const descriptor = await k.units.descriptorOf(methodHash);
+    g.check("T8", "method.registered", descriptor !== null && getAddress(descriptor.publisher) === getAddress(k.address(E)) && descriptor.kind === METHOD_KIND, `descriptor ${methodHash.slice(0, 10)}… (foga.realized-net-cash-flow/1) registered by E ${k.address(E)}`);
+    // --- the chain view the resolver reads
+    const chain = {
+        descriptor: async (h) => {
+            const d = await k.units.descriptorOf(h);
+            return d ? { kind: d.kind, publisher: d.publisher } : null;
+        },
+        latestVersion: (unitId) => k.units.latestVersion(unitId),
+        settled: async (inflow) => {
+            const m = /^erc8414:[^/]+\/(\d+)\/(\d+)$/.exec(inflow.ref);
+            if (m) {
+                const sub = await k.tenders.submissionOf(BigInt(m[1]), BigInt(m[2]));
+                const terms = await k.tenders.terms(BigInt(m[1]));
+                return { recipient: sub.fulfiller, amount: terms.rewardPerCompletion, settled: sub.status === 1 };
+            }
+            const e = /^erc8471:[^/]+\/(\d+)\/(\d+)$/.exec(inflow.ref);
+            if (e) {
+                const call = await k.adrf.call(BigInt(e[1]));
+                const s = await k.adrf.settlementOf(BigInt(e[1]), Number(e[2]));
+                return { recipient: call.provider, amount: call.amount, settled: s.stateName === "Released" };
+            }
+            return null;
+        },
+        assertion: async (id) => {
+            const a = await k.units.assertionOf(id);
+            if (a.kind === 0)
+                return null;
+            const o = await k.units.observationOf(id);
+            return { kind: a.kind, profileId: a.profileId, contentHash: a.contentHash, unitId: a.unitId, version: a.version, windowStart: o.windowStart, windowEnd: o.windowEnd };
+        },
+    };
+    const blockTime = async (block) => (await g.world.provider.getBlock(block ?? "latest")).timestamp;
+    /** The gas the given signers paid for the confirmed operations whose keys match, from the chain's receipts. */
+    const gasPaid = async (keyPattern, signers) => {
+        let wei = 0n;
+        let operations = 0;
+        for (const op of k.store.all()) {
+            if (op.status !== "confirmed" || !op.txHash || !keyPattern.test(op.key) || !signers.includes(op.signer))
+                continue;
+            const r = await g.world.provider.getTransactionReceipt(op.txHash);
+            if (!r)
+                continue;
+            wei += r.gasUsed * r.gasPrice;
+            operations++;
+        }
+        return { wei, operations };
+    };
+    // --- (2) cell A over T3-T7
+    const receiptA = await k.memo("T8.receipt.A", async () => {
+        const t3 = k.requireFact("T3.tokenId");
+        const t3Sub = k.requireFact("T3.submissionId");
+        const call1 = k.requireFact("T6.call1.id");
+        const call2 = k.requireFact("T6.call2.id");
+        const t7 = k.requireFact("T7.tokenId");
+        const t7Sub = k.requireFact("T7.A.submissionId");
+        const rogue = k.requireFact("T7.unattributed");
+        const price = (await k.adrf.call(BigInt(call2))).amount;
+        const reward3 = (await k.tenders.terms(BigInt(t3))).rewardPerCompletion;
+        const reward7 = (await k.tenders.terms(BigInt(t7))).rewardPerCompletion;
+        const inflows = [
+            { ref: `erc8414:${tenders}/${t3}/${t3Sub}`, source: "ERC-8414 tender settlement (T3, foga-probe)", recipient: A.address, amount: reward3.toString(), status: "counted", tx: k.store.get("T3.A.settle")?.txHash ?? null },
+            { ref: `erc8471:${escrow}/${call1}/1`, source: "ERC-8471 service call 1 (T6): settlement refunded by ruling", recipient: A.address, amount: "0", status: "excluded", reason: "the settlement was refunded to the client by the enacted ruling; nothing reached the provider", tx: k.store.get("T6.C.call1.enact")?.txHash ?? null },
+            { ref: `erc8471:${escrow}/${call2}/1`, source: "ERC-8471 service call 2 (T6): settlement released after the dispute period, withdrawn in T7", recipient: A.address, amount: price.toString(), status: "counted", tx: k.store.get("T7.A.derisk.withdraw")?.txHash ?? null },
+            { ref: `erc8414:${tenders}/${t7}/${rogue.submissionId}`, source: "ERC-8414 tender settlement (T7) to the operator key", recipient: rogue.fulfiller, amount: rogue.reward, status: "excluded", reason: "paid to the operator's own key, not through the cell account: not attributable to the unit", tx: k.store.get("T7.operator.settle")?.txHash ?? null },
+            { ref: `erc8414:${tenders}/${t7}/${t7Sub}`, source: "ERC-8414 tender settlement (T7, finch-extract-verify)", recipient: A.address, amount: reward7.toString(), status: "counted", tx: k.store.get("T7.A.settle")?.txHash ?? null },
+        ];
+        const gas = await gasPaid(/^T[3-7]\./, [A.roles.operator, A.roles.owner]);
+        const start = await blockTime(k.store.get("T3.B.mint")?.block);
+        const end = await k.blockTimestamp();
+        return {
+            schema: "foga.measurement-receipt/1",
+            method: "foga.realized-net-cash-flow/1",
+            methodHash,
+            unit: { registry: k.units.registryAddress, unitId: unitA.toString(), version: await k.units.latestVersion(unitA), name: "FOGA cell A" },
+            boundary: { accounts: [A.address], note: "the cell account only; the operator and owner keys are outside (their payments are not the cell's income; their gas is the cell's cost)" },
+            asset: `eip155:${chainId}/slip44:60`,
+            denomination: "wei",
+            window: { start, end, steps: ["T3", "T4", "T5", "T6", "T7"] },
+            inflows,
+            costs: { gasWei: gas.wei.toString(), operations: gas.operations, payer: `${accountRef(chainId, A.operatorAddress)} (operator), ${accountRef(chainId, A.ownerAddress)} (owner)`, note: "gas of the account's confirmed operations in the window, at the price paid" },
+            missing: ["model and inference fees of the skill runs (not observable on chain)", "the operator's gas for the refused bypass transaction (the operator's own act)"],
+            totals: totals(inflows, gas.wei),
+            measurer: accountRef(chainId, k.address(E)),
+        };
+    });
+    // --- (3) the swarm unit over T4-T5
+    const receiptSwarm = await k.memo("T8.receipt.swarm", async () => {
+        const t4 = k.requireFact("T4.tokenId");
+        const t5Sub = k.requireFact("T5.submissionId");
+        const nd = k.requireFact("T5.nd.tokenId");
+        const ndSub = k.requireFact("T5.nd.submissionId");
+        const reward4 = (await k.tenders.terms(BigInt(t4))).rewardPerCompletion;
+        const rewardNd = (await k.tenders.terms(BigInt(nd))).rewardPerCompletion;
+        const inflows = [
+            { ref: `erc8414:${tenders}/${t4}/${t5Sub}`, source: "ERC-8414 judged tender (T5): accepted by FOGA-Council, paid to the swarm account", recipient: swarmAccount, amount: reward4.toString(), status: "counted", tx: k.store.get("T5.execute")?.txHash ?? null },
+            { ref: `erc8414:${tenders}/${nd}/${ndSub}`, source: "ERC-8414 judged tender (T5, no decision): claimed after the judgment window, paid to the swarm account", recipient: swarmAccount, amount: rewardNd.toString(), status: "counted", tx: k.store.get("T5.nd.claimUnjudged")?.txHash ?? null },
+        ];
+        const start = await blockTime(k.store.get("T4.D.mint")?.block);
+        const end = await blockTime(k.store.get("T5.nd.claimUnjudged")?.block);
+        return {
+            schema: "foga.measurement-receipt/1",
+            method: "foga.realized-net-cash-flow/1",
+            methodHash,
+            unit: { registry: k.units.registryAddress, unitId: unitSwarm.toString(), version: await k.units.latestVersion(unitSwarm), name: "FOGA swarm (A, B, C)" },
+            boundary: { accounts: [swarmAccount], note: "the swarm account's receipts and payments; the members' own accounts and keys are outside" },
+            asset: `eip155:${chainId}/slip44:60`,
+            denomination: "wei",
+            window: { start, end, steps: ["T4", "T5"] },
+            inflows,
+            costs: { gasWei: "0", operations: 0, payer: "none inside the boundary", note: "the swarm account paid no gas itself; the members' keys paid for its transactions, outside the boundary" },
+            missing: ["gas paid by the members' keys for the swarm account's transactions", "model and inference fees of the deliverable"],
+            totals: totals(inflows, 0n),
+            measurer: accountRef(chainId, k.address(E)),
+        };
+    });
+    // the assertions: E, an independent measurer (not the units' controller)
+    const assertInput = (r) => ({ kind: AssertionKind.Observation, unitId: BigInt(r.unit.unitId), version: r.unit.version, profileId: methodHash, contentHash: receiptHash(r), contentURI: receiptUri(r), validFrom: 0, validUntil: 0, supersedes: "0x" + "00".repeat(32), payload: observationPayload(receiptHash(r), r.window.start, r.window.end) });
+    const opA = await k.call("T8.E.assert.A", E, k.units.assertionRegistryAddress, k.units.assertions().interface, "assertStatement", [assertInput(receiptA)]);
+    const assertionA = k.units.assertionIdFromReceipt(opA.receipt);
+    const opS = await k.call("T8.E.assert.swarm", E, k.units.assertionRegistryAddress, k.units.assertions().interface, "assertStatement", [assertInput(receiptSwarm)]);
+    const assertionS = k.units.assertionIdFromReceipt(opS.receipt);
+    k.setFact("T8.assertions", { A: assertionA, swarm: assertionS });
+    const storedA = await k.units.assertionOf(assertionA);
+    g.check("T8", "assertion.A", storedA.kind === AssertionKind.Observation && storedA.byController === false && getAddress(storedA.asserter) === getAddress(k.address(E)) && storedA.contentHash === receiptHash(receiptA), `assertion ${assertionA.slice(0, 10)}… on unit ${unitA}: Observation by E (not the controller), contentHash = keccak(JCS(receipt))`);
+    // --- (4) the resolver
+    const checkA = await checkReceipt(receiptA, [receiptSwarm], chain, assertionA);
+    const checkS = await checkReceipt(receiptSwarm, [receiptA], chain, assertionS);
+    k.setFact("T8.checks", { A: checkA, swarm: checkS });
+    g.check("T8", "resolver.A", checkA.pass, `receipt A: ${checkA.lines.filter((l) => l.pass).length}/${checkA.lines.length} rules pass; inflows ${receiptA.totals.inflowsWei} wei, gas ${receiptA.totals.costsWei} wei over ${receiptA.costs.operations} operations, net ${receiptA.totals.netWei} wei; missing: ${receiptA.missing.length} item(s)`);
+    g.check("T8", "resolver.swarm", checkS.pass, `receipt swarm: ${checkS.lines.filter((l) => l.pass).length}/${checkS.lines.length} rules pass; inflows ${receiptSwarm.totals.inflowsWei} wei to the swarm account; gas outside the boundary listed as missing`);
+    for (const [name, c] of [["A", checkA], ["swarm", checkS]])
+        for (const l of c.lines)
+            if (!l.pass)
+                g.log(`    ${name} ${l.rule}: ${l.detail}`);
+    // the boundary case: the swarm's tender counted for A's unit as well
+    const swarmInflow = receiptSwarm.inflows[0];
+    const bad = { ...receiptA, inflows: [...receiptA.inflows, { ...swarmInflow, recipient: A.address, source: `${swarmInflow.source} (wrongly attributed to A)` }] };
+    bad.totals = totals(bad.inflows, BigInt(receiptA.costs.gasWei));
+    const checkBad = await checkReceipt(bad, [receiptSwarm], chain);
+    const boundaryLine = checkBad.lines.find((l) => l.rule === `inflow.${swarmInflow.ref}`);
+    const onceLine = checkBad.lines.find((l) => l.rule === "once");
+    g.check("T8", "resolver.doubleCount", !checkBad.pass && boundaryLine?.pass === false && onceLine?.pass === false, `the swarm's tender counted for A: boundary rule fails (${boundaryLine?.detail}); once rule fails (${onceLine?.detail})`);
+    // an unregistered method is refused
+    const foreign = { ...receiptA, method: "someone-else/1", methodHash: keccakJcs({ method: "someone-else/1" }) };
+    const checkForeign = await checkReceipt(foreign, [], chain);
+    g.check("T8", "resolver.unregistered", !checkForeign.pass && checkForeign.lines.find((l) => l.rule === "method.registered")?.pass === false, `a receipt citing an unregistered method is refused: ${checkForeign.lines.find((l) => l.rule === "method.registered")?.detail}`);
+    // no receipt states a value
+    g.check("T8", "no.value", checkA.lines.find((l) => l.rule === "no-value")?.pass === true && checkS.lines.find((l) => l.rule === "no-value")?.pass === true, "neither receipt carries a value, price, worth, valuation or score field");
+    k.evidence("T8", "measurement", {
+        method: { hash: methodHash, kind: METHOD_KIND, publisher: k.address(E) },
+        receipts: { A: receiptA, swarm: receiptSwarm },
+        assertions: { A: assertionA, swarm: assertionS },
+        checks: { A: checkA, swarm: checkS, doubleCount: checkBad.lines.filter((l) => !l.pass), unregistered: checkForeign.lines.filter((l) => !l.pass) },
+        txs: { method: k.store.get("T8.E.method.register")?.txHash ?? null, assertA: opA.txHash, assertSwarm: opS.txHash },
+    });
+}

package/dist/genesis/t9.js

@@ -0,0 +1,188 @@
+import { CELL_GROUPS, operatorScope } from "./operator-scope.js";
+import { getAddress } from "ethers";
+import { AID } from "../core/aid.js";
+import { agentDescriptor, kindId, recordIdOf } from "../core/ard.js";
+import { Enforcement, Rights, accountSubjectKey, oneClause, scopeKeyOf } from "../core/asf.js";
+import { accountRef, keccakJcs } from "../core/canonical.js";
+import { accountSubject } from "../core/kya.js";
+import { cellUnitDefinition } from "../core/units.js";
+import { Cell } from "../kernel/cell.js";
+import { SUCCESSOR_CAPITAL } from "./funding.js";
+/**
+ * T9 — succession: an identity moves to a new body while the old one is still in full possession of its keys.
+ *  (9a) The owner deploys A-prime and configures it as a cell (operator, AID registry, classes); nothing executes
+ *       before A-prime presents its own safety binding (the old binding is A's). A transfers its ERC-8004 agent to
+ *       A-prime through its account; A's anchor turns STALE (the binding predicate no longer holds); A-prime binds
+ *       (takeover: the stale binding does not hold the agent hostage) and is ACTIVE; A retires naming A-prime as
+ *       successor; A-prime publishes a new ARD agent record and its own AID document. Failure cases: A-prime
+ *       binding before it holds the identity; a retirement acts only on its sender (no delegated form).
+ *  (9b) A transfers its finch-extract-verify skill token to A-prime; the ARD skill record's controller follows the
+ *       token, the record is no longer adopted (committed by a former controller) until A-prime recommits the
+ *       same descriptor hash.
+ *  (9c) Nothing else is inherited: A-prime has no KYA standing (A's assertions are A's), no swarm seat, no unit,
+ *       no binding of A's; A cannot make commitment-class calls once RETIRED; the successor pointer links the two
+ *       histories without merging them.
+ *  (9d) Key loss is documented, not demonstrated: with the guarded profile the owner rotates the operator and the
+ *       anchor stays; a lost anchor key under a lite profile cannot retire and the address stays STALE forever.
+ */
+export async function t9(g) {
+    const k = g.kernel;
+    const A = g.cell("A");
+    const chainId = g.chainId;
+    const G = k.address("G");
+    const spec = k.requireFact("T0.asf.spec");
+    const sAtt = k.requireFact("T0.kya.S_att").schemeId;
+    const agentId = BigInt(k.requireFact("T1.A.agentId"));
+    const skill = k.requireFact("T2.skill.finch-extract-verify");
+    const swarmId = k.requireFact("T4.swarmId");
+    const roles = { owner: A.roles.owner, operator: A.roles.operator, guardian: G };
+    // --- (9a) the new body
+    const prime = await Cell.deploy(k, {
+        key: "T9.Aprime.deploy",
+        name: "A-prime",
+        roles,
+        requirement: (predicted) => oneClause({
+            specRegistry: k.asf.specRegistryAddress,
+            specId: spec.specId,
+            versions: [spec.version],
+            adopter: predicted,
+            subjectKey: accountSubjectKey(chainId, predicted),
+            scopeKey: scopeKeyOf({ ref: accountRef(chainId, predicted) }),
+            enforcement: Enforcement.account | Enforcement.contract,
+            interveners: [{ account: G, rights: Rights.suspend | Rights.resume }],
+        }),
+    });
+    k.setFact("T9.Aprime.address", prime.address);
+    g.log(`  A-prime: account ${prime.address} (same owner and operator keys as A)`);
+    await k.transfer("T9.Aprime.fund", "W", prime.address, k.isLocalChain ? SUCCESSOR_CAPITAL.local : SUCCESSOR_CAPITAL.public);
+    await prime.admin("T9.Aprime.setOperator", "setOperator", [prime.operatorAddress, 0, 10n ** 16n]);
+    const primeScope = operatorScope(k, CELL_GROUPS["A-prime"]);
+    await prime.admin("T9.Aprime.scope", "setOperatorAllowedBatch", [primeScope.targets, primeScope.selectors, true]);
+    await prime.admin("T9.Aprime.setAIDRegistry", "setAIDRegistry", [k.aid.address]);
+    const tasks = k.tenders.contract().interface;
+    await prime.admin("T9.Aprime.class.8414.submitFulfillment", "setCommitmentClass", [k.tenders.address, g.selector(tasks, "submitFulfillment"), true]);
+    // the binding is A's, not A-prime's: nothing executes before A-prime presents its own
+    const bindCall = k.aid.encodeBind(k.identity.address, agentId);
+    const adopted = k.store.get("T9.Aprime.adopt")?.status === "confirmed";
+    if (!adopted) {
+        const unbound = await g.wouldRevert(prime, k.aid.address, bindCall);
+        g.check("T9", "inherit.binding.refused", unbound !== null && /BindingsNotPresented/.test(unbound), `A-prime executing before presenting a binding reverts: ${unbound}`);
+    }
+    else
+        g.skipped("T9", "inherit.binding.refused", "replayed run: A-prime already presents its binding");
+    const params = { profile: "foga-cell/1", cell: "A-prime", successorOf: accountRef(chainId, A.address) };
+    const authority = { kind: "owner", owner: accountRef(chainId, prime.ownerAddress), guardian: accountRef(chainId, G) };
+    const input = k.asf.cellBindingInput({ chainId, cell: prime.address, specId: spec.specId, version: spec.version, contentHash: spec.contentHash, guardian: G, params, authority });
+    const { bindingId: primeBinding } = await prime.adoptBinding("T9.Aprime.adopt", input, 0);
+    k.setFact("T9.Aprime.bindingId", primeBinding);
+    const primeStatus = await prime.status();
+    g.check("T9", "Aprime.binding", primeStatus.verdictName === "Satisfied", `A-prime adopted its own binding ${primeBinding.slice(0, 10)}…: status() = ${primeStatus.verdictName}`);
+    // before the identity moves: A-prime cannot bind what it does not hold
+    const transferred = k.store.get("T9.A.8004.transfer")?.status === "confirmed";
+    if (!transferred) {
+        const premature = await g.wouldRevert(prime, k.aid.address, bindCall);
+        g.check("T9", "bind.premature.refused", premature !== null && /NotAgentOfAnchor/.test(premature), `A-prime binding agent ${agentId} before holding it reverts: ${premature}`);
+        const stateBefore = await k.aid.stateName(A.address);
+        g.check("T9", "A.active.before", stateBefore === "ACTIVE", `state(A) = ${stateBefore} before the transfer`);
+    }
+    else {
+        g.skipped("T9", "bind.premature.refused", "replayed run: the identity was already transferred");
+        g.skipped("T9", "A.active.before", "replayed run: the identity was already transferred");
+    }
+    // the identity moves through A's own account
+    // moving the identity is the owner's act: the account refuses transfer selectors to the operator (revision 2)
+    const transfer = await A.execute("T9.A.8004.transfer", k.identity.address, k.identity.encodeTransfer(A.address, prime.address, agentId), { by: "owner" });
+    const ownerNow = await k.identity.contract().ownerOf(agentId);
+    const taken = k.store.get("T9.Aprime.aid.bind")?.status === "confirmed";
+    if (!taken) {
+        const stale = await k.aid.stateName(A.address);
+        g.check("T9", "A.stale", getAddress(ownerNow) === getAddress(prime.address) && stale === "STALE", `ownerOf(${agentId}) = A-prime; state(A) = ${stale}: the binding predicate no longer holds`);
+    }
+    else
+        g.skipped("T9", "A.stale", "replayed run: A-prime already took the binding over");
+    // takeover: the stale binding does not hold the agent hostage (in the backing registry too, where there is one)
+    const bind = await prime.execute("T9.Aprime.aid.bind", k.aid.address, bindCall);
+    if (k.aid.backing)
+        await prime.execute("T9.Aprime.aid.backing.bind", k.aid.backing.address, bindCall);
+    const anchorNow = await k.aid.contract().anchorOf(k.identity.address, agentId);
+    const primeState = await k.aid.stateName(prime.address);
+    const aBinding = await k.aid.bindingOf(A.address);
+    g.check("T9", "Aprime.active", getAddress(anchorNow) === getAddress(prime.address) && primeState === "ACTIVE" && aBinding.registry === "0x0000000000000000000000000000000000000000", `anchorOf(agent ${agentId}) = A-prime, state(A-prime) = ${primeState}; A's binding record is cleared by the takeover`);
+    if (k.aid.backing) {
+        const primeBacking = await k.aid.stateName(prime.address, k.aid.backing.address);
+        const aBacking = await k.aid.stateName(A.address, k.aid.backing.address);
+        g.check("T9", "Aprime.backing.active", primeBacking === "ACTIVE" && aBacking !== "ACTIVE", `in the backing registry ${k.aid.backing.address}: state(A-prime) = ${primeBacking}, state(A) = ${aBacking}`, "T9.A.aid.backing.retire");
+    }
+    // retirement: only the anchor itself, naming its successor
+    const retireFn = k.aid.contract().interface.getFunction("retire");
+    g.check("T9", "retire.noDelegate", retireFn !== null && retireFn.inputs.length === 1 && retireFn.inputs[0].name === "successor", `retire(successor) acts on msg.sender only: there is no form by which a third party retires A`);
+    await A.execute("T9.A.aid.retire", k.aid.address, k.aid.encodeRetire(prime.address));
+    if (k.aid.backing)
+        await A.execute("T9.A.aid.backing.retire", k.aid.backing.address, k.aid.encodeRetire(prime.address));
+    const aState = await k.aid.stateName(A.address);
+    const successor = await k.aid.contract().successorOf(A.address);
+    g.check("T9", "A.retired", aState === "RETIRED" && getAddress(successor) === getAddress(prime.address), `state(A) = ${aState}, successorOf(A) = ${successor}`);
+    const afterRetire = await g.wouldRevert(A, k.aid.address, k.aid.encodeHeartbeat());
+    g.check("T9", "A.retired.final", afterRetire !== null, `a retired anchor cannot heartbeat again: ${afterRetire}`);
+    // the new record and document of A-prime: a new agent, linked to the old one by the successor pointer only
+    const registration = { type: "https://eips.ethereum.org/EIPS/eip-8004#registration-v1", name: "FOGA cell A-prime", description: "The successor body of cell A of the Finch OG Agent genesis; the ERC-8004 agent moved here from A", services: [], supportedTrust: ["reputation"], "x-foga": { cell: "A-prime", anchor: accountRef(chainId, prime.address), predecessor: accountRef(chainId, A.address), binding: primeBinding } };
+    const descriptor = agentDescriptor({ chainId, anchor: prime.address, slug: "cell-a-prime", name: "FOGA cell A-prime", description: registration.description, capabilities: ["erc8414:fulfiller", "erc8338:holder"], registration: { registry: `eip155:${chainId}:${k.identity.address.toLowerCase()}`, agentId: agentId.toString() } });
+    const ard = await prime.execute("T9.Aprime.ard.register", k.ard.address, k.ard.encodeRegister(kindId("agent"), prime.address, 0n, descriptor));
+    const primeRecord = k.ard.recordIdFromReceipt(ard.receipt);
+    k.setFact("T9.Aprime.recordId", primeRecord);
+    const oldRecord = k.requireFact("T1.A.recordId");
+    const [newBacked, oldBacked] = await Promise.all([k.ard.backed(primeRecord), k.ard.backed(oldRecord)]);
+    g.check("T9", "Aprime.record", newBacked && primeRecord !== oldRecord && primeRecord === recordIdOf(chainId, prime.address, 0n), `A-prime's agent record ${primeRecord.slice(0, 10)}… (anchor (${chainId}, A-prime, 0)) is backed; A's record ${oldRecord.slice(0, 10)}… is a different record, backed = ${oldBacked} (its anchor is retired)`);
+    const doc = {
+        version: "aid-document/v1",
+        aid: accountRef(chainId, prime.address),
+        did: `did:aid:${accountRef(chainId, prime.address)}`,
+        binding: { registry: k.identity.address, agentId: Number(agentId) },
+        livenessWindow: Number(g.world.file.params.aid.defaultLivenessWindow),
+        facets: [{ facetType: "aid:core/identity/v1", provenance: "SELF", issuer: accountRef(chainId, prime.address), validUntil: 0, digest: keccakJcs(registration), access: { mode: "PUBLIC" }, resolver: { kind: "erc8004-identity", chainId, registry: k.identity.address, agentId: Number(agentId) } }],
+    };
+    const commitment = AID.documentCommitment(doc);
+    await prime.execute("T9.Aprime.aid.document", k.aid.address, k.aid.encodeSetDocumentURI(commitment.uri, commitment.digest));
+    const published = await k.aid.documentURI(prime.address);
+    g.check("T9", "Aprime.document", published.digest === commitment.digest, `documentURI(A-prime).digest = ${commitment.digest.slice(0, 10)}… (its own document; A's standing facet is not carried over)`);
+    // --- (9b) the skill moves; its record follows the token and is adopted again by recommitment
+    const tokenId = BigInt(skill.tokenId);
+    await A.execute("T9.A.skill.transfer", k.skills.address, k.skills.encodeSafeTransfer(A.address, prime.address, tokenId), { by: "owner" });
+    const skillOwner = await k.skills.ownerOf(tokenId);
+    const controller = await k.ard.controllerOf(skill.recordId);
+    const adoptedNow = await k.ard.isAdopted(skill.recordId);
+    const recommitted = k.store.get("T9.Aprime.skill.adopt")?.status === "confirmed";
+    g.check("T9", "skill.transferred", getAddress(skillOwner) === getAddress(prime.address) && getAddress(controller) === getAddress(prime.address) && (recommitted || adoptedNow === false), `ownerOf(${tokenId}) = A-prime; the ARD skill record's controller follows the token (${controller}); adopted = ${adoptedNow}${recommitted ? " (already recommitted in an earlier run)" : " until the new controller recommits"}`);
+    const rec = await k.ard.recordOf(skill.recordId);
+    await prime.execute("T9.Aprime.skill.adopt", k.ard.address, k.ard.encodeRecommit(skill.recordId, rec));
+    const adoptedAfter = await k.ard.isAdopted(skill.recordId);
+    const recAfter = await k.ard.recordOf(skill.recordId);
+    g.check("T9", "skill.adopted", adoptedAfter && getAddress(recAfter.attestor) === getAddress(prime.address) && recAfter.descriptorHash === rec.descriptorHash, `A-prime recommitted the same descriptor hash ${rec.descriptorHash.slice(0, 10)}…: attestor = controller = A-prime, adopted = ${adoptedAfter}`);
+    // --- (9c) nothing else is inherited
+    const standing = await k.kya.check(accountSubject(chainId, prime.address), sAtt, 2, [k.address("W")]);
+    const standingA = await k.kya.check(accountSubject(chainId, A.address), sAtt, 2, [k.address("W")]);
+    g.check("T9", "inherit.kya.none", standing === false && standingA === true, `check({account, A-prime}, S_att, 2, [W]) = ${standing}; A's own assertion still resolves for A (${standingA}): standing is the subject's, not the agent's`);
+    const seat = await k.swarms.memberStatus(swarmId, prime.address);
+    const seatA = await k.swarms.memberStatus(swarmId, A.address);
+    g.check("T9", "inherit.swarm.none", seat.statusName === "NONE" && seatA.statusName !== "NONE", `swarm seat: A-prime ${seat.statusName}, A ${seatA.statusName}: the seat stays with the account that joined`);
+    const primeUnits = (await Promise.all([k.units.controllerOf(BigInt(k.requireFact("T1.A.unitId")))])).map((c) => getAddress(c));
+    g.check("T9", "inherit.unit.none", primeUnits[0] === getAddress(A.address), `A's unit ${k.requireFact("T1.A.unitId")} is still controlled by A; A-prime registers its own`);
+    const unitDef = cellUnitDefinition({ chainId, cell: prime.address, name: "FOGA cell A-prime" });
+    const unit = await prime.execute("T9.Aprime.auf.unit", k.units.registryAddress, k.units.encodeRegisterUnit(prime.address, unitDef, []));
+    const primeUnit = k.units.unitIdFromReceipt(unit.receipt);
+    k.setFact("T9.Aprime.unitId", primeUnit.toString());
+    const retiredGate = await g.wouldRevert(A, k.tenders.address, k.tenders.encodeSubmit(BigInt(k.requireFact("T7.tokenId")), "0x" + "11".repeat(32), "retired"));
+    g.check("T9", "A.retired.gate", retiredGate !== null && /AnchorNotActive/.test(retiredGate), `a commitment-class call by the retired A reverts at the gate: ${retiredGate}`);
+    const primeBindings = await prime.presentedBindings();
+    const aBindings = await A.presentedBindings();
+    g.check("T9", "histories.separate", getAddress(successor) === getAddress(prime.address) && !primeBindings.includes(aBindings[0]) && primeRecord !== oldRecord, `successorOf(A) points at A-prime; A-prime's bindings, record and unit are its own: two histories, one pointer`);
+    k.evidence("T9", "succession", {
+        A: { account: A.address, state: aState, successor, record: oldRecord, bindings: aBindings, backingState: k.aid.backing ? await k.aid.stateName(A.address, k.aid.backing.address) : null },
+        Aprime: { account: prime.address, owner: prime.ownerAddress, operator: prime.operatorAddress, state: primeState, binding: primeBinding, record: primeRecord, unitId: primeUnit.toString(), documentDigest: commitment.digest },
+        agentId: agentId.toString(),
+        skill: { tokenId: skill.tokenId, recordId: skill.recordId, owner: skillOwner, adopted: adoptedAfter },
+        notInherited: ["KYA assertions (S_att level of A)", "swarm seat", "AUF unit", "ASF binding", "AID document facets"],
+        keyLoss: "documented in docs/genesis.md (9d): guarded profile rotates the operator under the same anchor; a lost anchor key under a lite profile cannot retire and stays STALE",
+        txs: { deploy: k.store.get("T9.Aprime.deploy")?.txHash, adopt: k.store.get("T9.Aprime.adopt")?.txHash, transfer: transfer.txHash, bind: bind.txHash, retire: k.store.get("T9.A.aid.retire")?.txHash, record: ard.txHash, skillTransfer: k.store.get("T9.A.skill.transfer")?.txHash, skillAdopt: k.store.get("T9.Aprime.skill.adopt")?.txHash, unit: unit.txHash },
+    });
+}

package/dist/genesis/zk.js

@@ -0,0 +1,128 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { keccak256, toBeHex, toUtf8Bytes } from "ethers";
+import { abi } from "../core/canonical.js";
+import { repoRoot } from "../util/fs.js";
+export const EPOCH_LENGTH = 2_592_000; // 30 days, as the upstream Sepolia adapter
+export const EPOCH_GRACE = 1;
+/** How long an assertion issued from a predicate proof stays valid: the rule was shown as of the proof's time. */
+export const PREDICATE_VALIDITY = 30 * 86400;
+/** The rule's window: completions inside the last 30 days before the proof. */
+export const PREDICATE_WINDOW = 30 * 86400;
+const BUILD = join("vendor", "kya-standard", "companions", "zk-kya-groth16", "build");
+export const PREDICATE_BUILD = join("zk", "build");
+export const PREDICATE_CIRCUIT = "kya_predicate_count_v1";
+/** Record slots per predicate proof (the committed circuit instance). */
+export const PREDICATE_SLOTS = 8;
+/** Where the proving material and the libraries stand on this machine. */
+export function zkAvailability(root = repoRoot()) {
+    const missing = [];
+    for (const f of ["kya_public_v1_js/kya_public_v1.wasm", "kya_final.zkey", "verification_key.json"]) {
+        if (!existsSync(join(root, BUILD, f)))
+            missing.push(join(BUILD, f));
+    }
+    if (!existsSync(join(root, "vendor", "kya-standard", "companions", "zk-kya-groth16", "prover.js")))
+        missing.push("vendor/kya-standard/companions/zk-kya-groth16/prover.js (run: foga vendor sync)");
+    if (!existsSync(join(root, "prover", "node_modules", "snarkjs")))
+        missing.push("prover/node_modules/snarkjs (run: npm run zk:install)");
+    return { ok: missing.length === 0, missing };
+}
+/** Whether the proving libraries (the prover sub-package) are installed; the source set root needs them. */
+export function proverLibsAvailable(root = repoRoot()) {
+    return existsSync(join(root, "prover", "node_modules", "snarkjs")) && existsSync(join(root, "prover", "node_modules", "circomlibjs"));
+}
+/** Where the predicate circuit's proving material stands (built by prover/build-predicate.mjs; FOGA_ZK_PREDICATE_DIR overrides). */
+export function predicateAvailability(root = repoRoot()) {
+    const missing = [];
+    const dir = process.env.FOGA_ZK_PREDICATE_DIR || join(root, PREDICATE_BUILD);
+    for (const f of [`${PREDICATE_CIRCUIT}_js/${PREDICATE_CIRCUIT}.wasm`, `${PREDICATE_CIRCUIT}_final.zkey`, "verification_key.json"]) {
+        if (!existsSync(join(dir, f)))
+            missing.push(`${join(PREDICATE_BUILD, f)} (run: node prover/build-predicate.mjs)`);
+    }
+    if (!proverLibsAvailable(root))
+        missing.push("prover/node_modules (run: npm run zk:install)");
+    return { ok: missing.length === 0, missing };
+}
+/** A deterministic 32-byte EdDSA private key for a source of task-completion records, from an EOA key and a label. */
+export function sourceKeyFrom(privateKey, label) {
+    return keccak256(abi.encode(["bytes32", "bytes32"], [keccak256(toUtf8Bytes(`foga.kya.source:${label}`)), privateKey]));
+}
+/** A deterministic 32-byte EdDSA private key for an attestor, derived from an EOA key and a label. */
+export function attestorKeyFrom(privateKey, label) {
+    return keccak256(abi.encode(["bytes32", "bytes32"], [keccak256(toUtf8Bytes(`foga.kya.attestor:${label}`)), privateKey]));
+}
+/** A deterministic prover secret below the BN254 scalar field (248 bits), derived from an EOA key and a scheme. */
+export function proverSecretFrom(privateKey, schemeId) {
+    const h = BigInt(keccak256(abi.encode(["bytes32", "bytes32", "bytes32"], [keccak256(toUtf8Bytes("foga.kya.secret")), privateKey, schemeId])));
+    return toBeHex(h >> 8n, 32);
+}
+export function epochFor(timestamp, epochLength = EPOCH_LENGTH) {
+    return epochLength === 0 ? 0n : BigInt(Math.floor(timestamp / epochLength));
+}
+async function run(job, timeoutMs = 180_000) {
+    const root = repoRoot();
+    const script = join(root, "prover", "run.cjs");
+    return new Promise((resolve, reject) => {
+        const env = { PATH: process.env.PATH ?? "" };
+        if (process.env.FOGA_ZK_PROVER)
+            env.FOGA_ZK_PROVER = process.env.FOGA_ZK_PROVER;
+        if (process.env.FOGA_ZK_PREDICATE_DIR)
+            env.FOGA_ZK_PREDICATE_DIR = process.env.FOGA_ZK_PREDICATE_DIR;
+        const child = spawn(process.execPath, [script], { stdio: ["pipe", "pipe", "pipe"], env });
+        const out = [];
+        const err = [];
+        const timer = setTimeout(() => {
+            child.kill("SIGKILL");
+            reject(new Error(`prover ${job.op} exceeded ${timeoutMs} ms`));
+        }, timeoutMs);
+        child.stdout.on("data", (d) => out.push(Buffer.from(d)));
+        child.stderr.on("data", (d) => err.push(Buffer.from(d)));
+        child.on("error", (e) => {
+            clearTimeout(timer);
+            reject(e);
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            if (code !== 0)
+                return reject(new Error(`prover ${job.op} exited with ${code}: ${Buffer.concat(err).toString("utf8").slice(0, 2000)}`));
+            try {
+                resolve(JSON.parse(Buffer.concat(out).toString("utf8")));
+            }
+            catch (e) {
+                reject(new Error(`prover ${job.op} returned no JSON: ${String(e)}`));
+            }
+        });
+        child.stdin.end(JSON.stringify(job));
+    });
+}
+export const zk = {
+    /** The issuer set of the given attestor keys: Poseidon Merkle root (depth 16) and the public keys. */
+    issuerSet(attestors) {
+        return run({ op: "root", attestors });
+    },
+    /** Poseidon(secret): the prover's commitment, the only thing the attestor needs from it. */
+    commit(secret) {
+        return run({ op: "commit", secret });
+    },
+    /** The attestor signs (claim, commitment). */
+    attest(attestor, claim, commitment) {
+        return run({ op: "attest", attestor, claim, commitment });
+    },
+    /** The prover builds the Groth16 proof for the registry's admission domain and the epoch; public material only. */
+    prove(p) {
+        return run({ ...p, op: "prove", epoch: p.epoch.toString() });
+    },
+    /** The source set of the given source keys: the same Poseidon Merkle tree (depth 16) as the issuer set. */
+    sourceSet(sources) {
+        return run({ op: "root", attestors: sources });
+    },
+    /** A source signs one task-completion record about a subject. */
+    signRecord(source, subjectKey, record) {
+        return run({ op: "record.sign", source, record: { ...record, subjectKey } });
+    },
+    /** The prover shows that at least k of the records are Accepted inside [t0, t1]; records and source stay private. */
+    provePredicate(p) {
+        return run({ ...p, op: "predicate.prove", epoch: p.epoch.toString() }, 600_000);
+    },
+};