@supercuts-walrus/backend 0.1.0 → 0.1.2

package/README.md

@@ -77,7 +77,7 @@ bytes under that operation ID; retrying another payload with the same ID fails.
 
 ## Procurement demo
 
-For the Codex buyer with three remote Claude-backed sellers, Supabase-backed seller state, and the separate Render facilitator, follow [the remote demo guide](../docs/remote-codex-demo.md). The remote path is live-only and gives Codex a buyer role MCP server; the three seller panes use the safe `supercuts-seller-watch` event stream.
+For the Codex buyer with three remote sellers, Claude-researched and owner-reviewed artifacts, Supabase-backed seller state, and the separate Render facilitator, follow [the remote demo guide](../docs/remote-codex-demo.md). The remote path is live-only and gives Codex a buyer role MCP server; the three seller panes use the safe `supercuts-seller-watch` event stream.
 
 `supercuts-demo` is the operator entry point:
 
@@ -116,9 +116,11 @@ For a Claude-agent recording, export `CLAUDE_API_KEY` or provide
 `live --claude-key-file <owner-only-file>`; a repository `.env` file is not
 loaded automatically. Validate the credential against Anthropic before starting
 a funded take.
-The live path calls Claude for bounded buyer and seller decisions and records
-only the model, action, and token counts. The backend still enforces capability,
-amount, rail, and agreement bindings. Validate that recording with
+The recorded workflow can call Claude for bounded buyer decisions and records
+only the model, action, and token counts. Hosted seller price and agreement
+decisions are deterministic after backend validation; Claude web research runs
+before provisioning so model availability cannot interrupt a paid request. The
+backend still enforces capability, amount, rail, and agreement bindings. Validate that recording with
 `supercuts-demo check --require-claude`; an earlier funded run without these
 agent-decision events does not satisfy that gate.
 
@@ -185,7 +187,28 @@ signer, pool notes, Walrus and Walrus Memory configuration. A missing file
 returns `DEAL_SELLERS_NOT_CONFIGURED`. An owner-only `deal-ports.mjs` exporting
 `createDealPorts(app, mandate)` remains available as an advanced override.
 
-The seller service is `supercuts-seller-live <seller-home> <config.json>`.
+Create a seller home with `supercuts onboard seller --home <seller-home>` or
+its noninteractive `--config <owner-only-setup.json>` form. It generates a
+fresh seller signer by default, writes a seller MCP stanza, and explicitly
+reports that the seller should not receive faucet funds. The seller service is
+`supercuts-seller-live <seller-home> <config.json>`.
+Use `supercuts seller scaffold` to generate the offer spec, replaceable handler,
+future expiry, environment-based facilitator config, and exact next commands.
+The npm tarball includes pinned metadata for x402-only sellers; shielded sellers
+still install the proof artifacts required for recovery and exits.
+
+Research sellers can create a source-backed draft before packaging:
+
+```sh
+CLAUDE_API_KEY=... supercuts seller research --kind market-brief \
+  --topic "Current Sui ecosystem market structure and risks" \
+  --output <owner-only-draft.json>
+```
+
+The command uses Anthropic web search, rejects citations absent from the search
+evidence, and writes a mode-0600 draft marked `draft-needs-owner-review`.
+Optional `--allowed-domains` constrains sources. It never publishes or changes
+live seller state; an owner must review and approve the immutable bytes first.
 Register each capability first with
 `supercuts-seller-register <seller-home> <spec.json> <registration.json>`.
 The spec contains `capabilityId`, `capability`, `description`, `inputSchema`,

package/config/phase1.testnet.json

@@ -0,0 +1,20 @@
+{
+  "network": "testnet",
+  "sender": "0x66fdfe84ff521627c93910c93ec0bc26934ee1fef3a1a0a5ce14b7dc4567ec00",
+  "coinType": "0x2::sui::SUI",
+  "coinTypeHash": "be4507e04f555448ca05c0c9f8345c5ea9f3e40e8616a20f5d5c18b40ef399eb",
+  "packageId": "0x32d104c1ab422d497df4ae3a6861258694949c86428f886ca338e07bd055cf76",
+  "poolId": "0x8fd22140c906495bb5334a497dcdd9112479c638e21c5df4b4cfb66f633a106b",
+  "poolCreateTransaction": "BnzMqokgQVWwSkRYCCrMTyWwHN6HVdDKWwVDJXTZqC6b",
+  "deploymentCheckpoint": "401762744",
+  "deploymentDomain": "3082f331660eb38075e250a810a701bc4b0de2ca329eda70b2d76e3795517305",
+  "initialRoot": "2134e76ac5d21aab186c2be1dd8f84ee880a1e46eaf712f9d371b6df22191f3e",
+  "verifierVersion": 2,
+  "testOnly": true,
+  "artifactManifest": "config/proving-manifest.json",
+  "artifacts": {
+    "deposit": { "r1csSha256": "f36a1a18bf9d243e089e6ab14436e5a921d2b839d81bea95db319a4cdb80a197", "zkeySha256": "d398776a54628c390e8bf822007e47ed8fac00e92e8ea95bb17d20db517998dc", "verifyingKeySha256": "838404ff0ae3a9fc82da0856b68a11428cf3ffef335b4c6539fa1860d8e1ba26" },
+    "transfer": { "r1csSha256": "055ea2ec8f689c48e59f89fe06db6fb980dc575982214bfe60f675e8f08485c3", "zkeySha256": "6e7bcac98b8d2a78fd1811e2caadd83d0d6a301951f8cf27ac55a67006b001c2", "verifyingKeySha256": "8a6896f3f330769aa69e0dc1251a19fb69c4d6264b5729d0104df8d262e573ba" },
+    "withdraw": { "r1csSha256": "85cf1542ab2f2ece4bbd8757def48d526ba0951a832a2e0ebbf97ace2c611308", "zkeySha256": "fd303dd0dd53b9b752dac0de546dabdd03198a7a4defde5e8d6018bccd419c56", "verifyingKeySha256": "445c1982bea5e465fb0f5665023bb279637d820a9425f16a4c2f2ee7460e7e4a" }
+  }
+}

package/config/proving-manifest.json

@@ -0,0 +1,11 @@
+{
+  "version": "supercuts-pool-v2",
+  "testOnly": true,
+  "warning": "Per-circuit contributions are locally generated and unaudited; never use these keys with production assets.",
+  "powersOfTauSha256": "3f428d1a407e4704ef906960e000b03089e5e6ec29bf65b07bb5e3de005f4700",
+  "circuits": {
+    "deposit": { "r1csSha256": "f36a1a18bf9d243e089e6ab14436e5a921d2b839d81bea95db319a4cdb80a197", "zkeySha256": "d398776a54628c390e8bf822007e47ed8fac00e92e8ea95bb17d20db517998dc", "verificationKeySha256": "838404ff0ae3a9fc82da0856b68a11428cf3ffef335b4c6539fa1860d8e1ba26", "proofSha256": "9b7835852cd9ced7c02828e5c563191ac597f7175b04fa9bb01c66cc93a93e58", "publicInputsSha256": "23569e5994ddd08b555dcbcf12c735ec303e000f6e7e90c9b63667dec60b6aeb" },
+    "transfer": { "r1csSha256": "055ea2ec8f689c48e59f89fe06db6fb980dc575982214bfe60f675e8f08485c3", "zkeySha256": "6e7bcac98b8d2a78fd1811e2caadd83d0d6a301951f8cf27ac55a67006b001c2", "verificationKeySha256": "8a6896f3f330769aa69e0dc1251a19fb69c4d6264b5729d0104df8d262e573ba", "proofSha256": "ff9a902e91e7d7b64e278cc7e17c22ad3f031f350aacb43f610771adafbf3f35", "publicInputsSha256": "903861e7ee9f792a17194f96649736d4916f45605918acac78e5d40a5b8f6170" },
+    "withdraw": { "r1csSha256": "85cf1542ab2f2ece4bbd8757def48d526ba0951a832a2e0ebbf97ace2c611308", "zkeySha256": "fd303dd0dd53b9b752dac0de546dabdd03198a7a4defde5e8d6018bccd419c56", "verificationKeySha256": "445c1982bea5e465fb0f5665023bb279637d820a9425f16a4c2f2ee7460e7e4a", "proofSha256": "4746ee54c04389929aad48c0c5a0cf18985b9dd6bcd7a3b83aa717d8847973d3", "publicInputsSha256": "d18d5852ac3c636c7b081bc52d367c896c95bd5a89feacc91014afefe3dcff54" }
+  }
+}

package/dist/buyer-setup.js

@@ -48,10 +48,10 @@ function validateConfig(config) {
         fail("SETUP_INVALID", "configure a directoryUrl or sellerOrigins");
     if (config.directoryUrl)
         origins([config.directoryUrl]);
-    for (const key of ["deploymentConfig", "tatumKeyFile", "writeGrpc", "tatumGrpc", "walrusPublisher", "walrusAggregator", "memoryConfigFile"])
+    for (const key of ["deploymentConfig", "tatumKeyFile", "writeGrpc", "tatumGrpc", "walrusPublisher", "walrusAggregator"])
         if (typeof config[key] !== "string" || !config[key])
             fail("SETUP_INVALID", `${key} is required`);
-    for (const path of [config.tatumKeyFile, config.memoryConfigFile, ...(config.suiKeyFile ? [config.suiKeyFile] : [])])
+    for (const path of [config.tatumKeyFile, ...(config.memoryConfigFile ? [config.memoryConfigFile] : []), ...(config.suiKeyFile ? [config.suiKeyFile] : [])])
         ownerFile(resolve(path));
     const deployment = JSON.parse(readFileSync(resolve(config.deploymentConfig), "utf8"));
     if (deployment.network !== "testnet" || deployment.verifierVersion !== 2)
@@ -69,7 +69,7 @@ function writePolicy(home, config) {
     const base = { ...mandate };
     delete base.allowedCapabilityIds;
     delete base.allowedCapabilityClasses;
-    const next = { ...base, version: "supercuts.mandate.v2", allowedCommands: [...new Set([...mandate.allowedCommands, "deal.execute", "deal.get", "deal.resume", "deal.evidence", "deal.delivery", "deal.catalog", "deal.policy", "settlement.plan", "memory.inventory"])], allowedCounterparties: config.allowedCounterparties ?? [], perDealCeiling: config.perDealCeiling, totalRunBudget: config.totalBudget, expiresAt: config.expiresAt, requiredPrivacy: "any", requireSettlementPlan: true, allowedRails: config.allowPublicX402 === true ? ["shielded", "x402"] : ["shielded"], allowPublicX402: config.allowPublicX402 === true, ...(config.allowedCapabilityIds ? { allowedCapabilityIds: config.allowedCapabilityIds } : {}), ...(config.allowedCapabilityClasses ? { allowedCapabilityClasses: config.allowedCapabilityClasses } : {}) };
+    const next = { ...base, version: "supercuts.mandate.v2", allowedCommands: [...new Set([...mandate.allowedCommands, "deal.execute", "deal.get", "deal.resume", "deal.evidence", "deal.delivery", "deal.catalog", "deal.policy", "settlement.plan", "memory.inventory", "remote.research"])], allowedCounterparties: config.allowedCounterparties ?? [], perDealCeiling: config.perDealCeiling, totalRunBudget: config.totalBudget, expiresAt: config.expiresAt, requiredPrivacy: "any", requireSettlementPlan: true, allowedRails: config.allowPublicX402 === true ? ["shielded", "x402"] : ["shielded"], allowPublicX402: config.allowPublicX402 === true, ...(config.allowedCapabilityIds ? { allowedCapabilityIds: config.allowedCapabilityIds } : {}), ...(config.allowedCapabilityClasses ? { allowedCapabilityClasses: config.allowedCapabilityClasses } : {}) };
     writeFileSync(path, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
     chmodSync(path, 0o600);
     writeFileSync(join(home, "deal-sellers.json"), `${JSON.stringify(config.directoryUrl ? { directoryUrl: origins([config.directoryUrl])[0], origins: config.sellerOrigins?.length ? origins(config.sellerOrigins) : [] } : origins(config.sellerOrigins ?? []), null, 2)}\n`, { mode: 0o600 });
@@ -94,7 +94,7 @@ export async function promptBuyerSetup(home) {
             deploymentConfig: await ask("Pinned Testnet deployment config path"), tatumKeyFile: await ask("Tatum key file path"),
             writeGrpc: await ask("Sui write gRPC URL"), tatumGrpc: await ask("Tatum read gRPC URL"),
             walrusPublisher: await ask("Walrus publisher URL"), walrusAggregator: await ask("Walrus aggregator URL"),
-            memoryConfigFile: await ask("Owner-only Walrus Memory config path"),
+            memoryConfigFile: await ask("Owner-only Walrus Memory config path (blank to skip Memory)"),
             directoryUrl: await ask("Shared directory origin (blank for direct sellers)"),
             sellerOrigins: (await ask("Additional seller HTTPS origins, comma separated (or blank)")).split(",").map((item) => item.trim()).filter(Boolean),
             allowedCounterparties: (await ask("Initially approved seller Sui addresses, comma separated (or blank)")).split(",").map((item) => item.trim()).filter(Boolean),
@@ -118,7 +118,7 @@ function setupBuyerConfig(home, config) {
     if (!config.suiKeyFile)
         writeFileSync(keyPath, Ed25519Keypair.generate().getSecretKey(), { mode: 0o600, flag: "wx" });
     ownerFile(keyPath);
-    initialize(home, { role: "buyer", "deployment-config": resolve(config.deploymentConfig), "sui-key-file": keyPath, "tatum-key-file": resolve(config.tatumKeyFile), "write-grpc": config.writeGrpc, "tatum-grpc": config.tatumGrpc, "walrus-publisher": config.walrusPublisher, "walrus-aggregator": config.walrusAggregator, "memory-config-file": resolve(config.memoryConfigFile), "allow-counterparty": (config.allowedCounterparties ?? []).join(","), "max-amount": config.perDealCeiling, ...(config.rapidsnark ? { rapidsnark: resolve(config.rapidsnark) } : {}) });
+    initialize(home, { role: "buyer", "deployment-config": resolve(config.deploymentConfig), "sui-key-file": keyPath, "tatum-key-file": resolve(config.tatumKeyFile), "write-grpc": config.writeGrpc, "tatum-grpc": config.tatumGrpc, "walrus-publisher": config.walrusPublisher, "walrus-aggregator": config.walrusAggregator, ...(config.memoryConfigFile ? { "memory-config-file": resolve(config.memoryConfigFile) } : {}), "allow-counterparty": (config.allowedCounterparties ?? []).join(","), "max-amount": config.perDealCeiling, ...(config.rapidsnark ? { rapidsnark: resolve(config.rapidsnark) } : {}) });
     writePolicy(home, config);
     const session = createBuyerSession(home);
     const decoded = decodeSuiPrivateKey(readFileSync(keyPath, "utf8").trim());
@@ -206,7 +206,7 @@ export async function approveBuyerSeller(home, capabilityId) {
     profile.policy.allowedCounterparties = updated.allowedCounterparties;
     writeFileSync(path, `${JSON.stringify(updated, null, 2)}\n`, { mode: 0o600 });
     writeFileSync(profilePath, `${JSON.stringify(profile, null, 2)}\n`, { mode: 0o600 });
-    return { capabilityId, sellerId: registration.manifest.sellerId, approved: true };
+    return { capabilityId, sellerId: registration.manifest.sellerId, approved: true, manifestHash: registration.manifest.manifestHash, description: registration.manifest.description, priceBand: registration.manifest.priceBand, asset: registration.manifest.asset, supportedRails: registration.manifest.supportedRails, expiresAt: registration.manifest.expiresAt };
 }
 export async function addBuyerPrivacyRule(home, capabilityId) {
     const app = new Phase3App(home);

package/dist/cli.js

@@ -2,18 +2,24 @@
 import { Phase3App, errorOutput, homePath, initialize, parseArgs } from "./phase3.js";
 import { addBuyerPrivacyRule, approveBuyerSeller, createBuyerSession, promptBuyerSetup, renewBuyer, setupBuyer } from "./buyer-setup.js";
 import { onboardingDoctor } from "./onboarding-doctor.js";
+import { executeFunding, prepareFunding } from "./funding.js";
+import { packageHostedSeller } from "./seller-package.js";
+import { promptSellerSetup, setupSeller } from "./seller-setup.js";
+import { scaffoldSeller } from "./seller-scaffold.js";
+import { generateSellerResearch } from "./seller-research.js";
 const words = process.argv.slice(2);
 let command = words.shift() ?? "";
-if (["wallet", "offer", "pay", "resource", "memory", "audit", "capability", "settlement", "setup", "policy", "onboarding"].includes(command))
+if (["wallet", "offer", "pay", "resource", "memory", "audit", "capability", "settlement", "setup", "policy", "onboarding", "onboard", "funding", "seller"].includes(command))
     command += `.${words.shift() ?? ""}`;
 try {
     if (!command || command === "help" || command === "--help" || command === "setup.") {
-        process.stdout.write(`${JSON.stringify({ schemaVersion: "supercuts.help.v1", ok: true, commands: ["setup buyer", "setup renew", "setup session", "init", "doctor", "status", "wallet", "offer", "pay", "memory", "capability", "audit"], setup: "Run supercuts setup buyer --home <private-directory> for guided live Testnet setup. Run supercuts init --role <buyer|seller|auditor> --mock --home <private-directory> for a local non-funded profile. Keep each role in a separate owner-only home.", live: "Supply the pinned Testnet deployment config, owner-only credential files, Sui and Tatum RPC endpoints, Walrus endpoints, local proving artifacts, and RapidSnark. Fund only the buyer address printed by supercuts-demo setup." })}\n`);
+        process.stdout.write(`${JSON.stringify({ schemaVersion: "supercuts.help.v1", ok: true, commands: ["onboard buyer", "onboard seller", "seller scaffold", "seller research", "seller package", "funding prepare", "funding execute", "setup buyer", "setup seller", "setup renew", "setup session", "init", "doctor", "status", "wallet", "offer", "pay", "memory", "capability", "audit"], setup: "Run supercuts onboard buyer or supercuts onboard seller with an isolated --home. Then use seller scaffold to generate a capability. Research sellers can use seller research to create a cited owner-review draft before packaging.", live: "Fund only the generated buyer address. A seller does not need faucet funds to publish or receive a capability payment." })}\n`);
         process.exit(0);
     }
     const args = parseArgs(words);
     const home = homePath(args);
-    const result = command === "init" ? initialize(home, args) : command === "setup.buyer" ? { schemaVersion: "supercuts.setup.v1", ok: true, command, data: typeof args.config === "string" ? setupBuyer(home, args.config) : await promptBuyerSetup(home) } : command === "setup.renew" ? { schemaVersion: "supercuts.setup.v1", ok: true, command, data: renewBuyer(home, String(args.config ?? "")) } : command === "setup.session" ? { schemaVersion: "supercuts.setup.v1", ok: true, command, data: createBuyerSession(home) } : command === "policy.add" ? { schemaVersion: "supercuts.setup.v1", ok: true, command, data: await addBuyerPrivacyRule(home, String(args["capability-id"] ?? "")) } : command === "policy.approve-seller" ? { schemaVersion: "supercuts.setup.v1", ok: true, command, data: await approveBuyerSeller(home, String(args["capability-id"] ?? "")) } : command === "onboarding.doctor" ? { schemaVersion: "supercuts.onboarding.v1", ok: true, command, data: await onboardingDoctor(home, typeof args.config === "string" ? args.config : undefined) } : await (async () => { const app = new Phase3App(home); try {
+    const fundingInput = { publicPayment: String(args["public-payment"] ?? "0"), shieldedPayment: String(args["shielded-payment"] ?? "0"), ...(typeof args["gas-reserve"] === "string" ? { gasReserve: args["gas-reserve"] } : {}), ...(typeof args["change-reserve"] === "string" ? { changeReserve: args["change-reserve"] } : {}) };
+    const result = command === "init" ? initialize(home, args) : command === "setup.buyer" || command === "onboard.buyer" ? { schemaVersion: "supercuts.setup.v1", ok: true, command, data: typeof args.config === "string" ? setupBuyer(home, args.config) : await promptBuyerSetup(home) } : command === "setup.seller" || command === "onboard.seller" ? { schemaVersion: "supercuts.setup.v1", ok: true, command, data: typeof args.config === "string" ? setupSeller(home, args.config) : await promptSellerSetup(home) } : command === "seller.scaffold" ? { schemaVersion: "supercuts.seller-scaffold.v1", ok: true, command, data: scaffoldSeller({ ...args, home }) } : command === "seller.research" ? { schemaVersion: "supercuts.seller-research.v1", ok: true, command, data: await generateSellerResearch({ kind: String(args.kind ?? ""), topic: String(args.topic ?? ""), output: String(args.output ?? ""), ...(typeof args["context-file"] === "string" ? { contextFile: args["context-file"] } : {}), ...(typeof args["allowed-domains"] === "string" ? { allowedDomains: args["allowed-domains"] } : {}), ...(typeof args.model === "string" ? { model: args.model } : {}) }) } : command === "setup.renew" ? { schemaVersion: "supercuts.setup.v1", ok: true, command, data: renewBuyer(home, String(args.config ?? "")) } : command === "setup.session" ? { schemaVersion: "supercuts.setup.v1", ok: true, command, data: createBuyerSession(home) } : command === "funding.prepare" ? { schemaVersion: "supercuts.funding.v1", ok: true, command, data: await prepareFunding(home, fundingInput) } : command === "funding.execute" ? { schemaVersion: "supercuts.funding.v1", ok: true, command, data: await executeFunding(home, { ...fundingInput, operationId: String(args["operation-id"] ?? ""), requestFaucet: args["request-faucet"] === true, confirmed: args.confirm === true }) } : command === "seller.package" ? { schemaVersion: "supercuts.seller-package.v1", ok: true, command, data: await packageHostedSeller({ home, spec: String(args.spec ?? ""), artifact: String(args.artifact ?? ""), metadata: String(args.metadata ?? ""), registration: String(args.registration ?? ""), bundle: String(args.bundle ?? ""), ...(typeof args["content-type"] === "string" ? { contentType: args["content-type"] } : {}) }) } : command === "policy.add" ? { schemaVersion: "supercuts.setup.v1", ok: true, command, data: await addBuyerPrivacyRule(home, String(args["capability-id"] ?? "")) } : command === "policy.approve-seller" ? { schemaVersion: "supercuts.setup.v1", ok: true, command, data: await approveBuyerSeller(home, String(args["capability-id"] ?? "")) } : command === "onboarding.doctor" ? { schemaVersion: "supercuts.onboarding.v1", ok: true, command, data: await onboardingDoctor(home, typeof args.config === "string" ? args.config : undefined) } : await (async () => { const app = new Phase3App(home); try {
         return await app.execute(command, args);
     }
     finally {

package/dist/deal-adapter.js

@@ -16,8 +16,6 @@ export async function createConfiguredDealEngine(app) {
         fail("MANDATE_COMMAND_FORBIDDEN", "owner mandate does not allow composite deal execution");
     const path = join(app.home, "deal-ports.mjs");
     if (!existsSync(path)) {
-        if (!app.store.getSecret("live:memory-config"))
-            fail("LIVE_MEMORY_CONFIG_MISSING", "live composite deals require an owner-only Walrus Memory configuration");
         return new DealEngine(new DealJournal(app.store), new LiveDealPorts(app, mandate), mandate);
     }
     if ((statSync(path).mode & 0o077) !== 0)

package/dist/deal-engine.js

@@ -179,10 +179,10 @@ export class DealEngine {
         if (existing?.blobId) {
             const indexed = await this.ports.inventory(existing.blobId);
             this.journal.recordOutcome(operationId, existing.payloadHash, existing.blobId, indexed);
-            return indexed ? this.journal.advance(operationId, "outcome_pending", "complete") : this.journal.get(operationId);
+            return this.journal.advance(operationId, "outcome_pending", "complete");
         }
         if (existing)
-            return view;
+            return this.journal.advance(operationId, "outcome_pending", "complete");
         const plan = this.journal.step(operationId, "planning") ?? fail("DEAL_PLAN_MISSING", "saved deal plan is missing");
         const payment = this.journal.step(operationId, "payment") ?? fail("DEAL_PAYMENT_UNVERIFIED", "saved deal payment is missing");
         const artifact = this.journal.step(operationId, "delivery") ?? fail("DEAL_DELIVERY_UNVERIFIED", "saved deal delivery is missing");
@@ -193,11 +193,11 @@ export class DealEngine {
             this.journal.recordTiming(operationId, "outcome_queue", Date.now() - started);
             if ("unresolved" in candidate) {
                 this.journal.setOutcomeUnresolved(operationId);
-                return this.journal.get(operationId);
+                return this.journal.advance(operationId, "outcome_pending", "complete");
             }
             if ("queued" in candidate) {
                 this.journal.queueOutcome(operationId, candidate.payloadHash);
-                return this.journal.get(operationId);
+                return this.journal.advance(operationId, "outcome_pending", "complete");
             }
             if (!candidate.blobId || !/^[0-9a-f]{64}$/.test(candidate.payloadHash))
                 fail("DEAL_MEMORY_INVALID", "outcome memory is incomplete");
@@ -206,6 +206,6 @@ export class DealEngine {
         }
         const indexed = await this.ports.inventory(outcome.blobId);
         this.journal.recordOutcome(operationId, outcome.payloadHash, outcome.blobId, indexed);
-        return indexed ? this.journal.advance(operationId, "outcome_pending", "complete") : this.journal.get(operationId);
+        return this.journal.advance(operationId, "outcome_pending", "complete");
     }
 }

package/dist/deal.js

@@ -213,8 +213,8 @@ export class DealJournal {
                 fail("DEAL_PAYMENT_UNVERIFIED", "confirmed payment evidence is required");
             if (next === "delivered" && !(this.store.db.prepare("SELECT 1 FROM deal_blobs WHERE operation_id=? AND kind='delivery' AND status='verified'").get(operationId)))
                 fail("DEAL_DELIVERY_UNVERIFIED", "verified delivery evidence is required");
-            if (next === "complete" && !(this.store.db.prepare("SELECT 1 FROM deal_memory_outbox WHERE operation_id=? AND event_kind='outcome' AND status='indexed'").get(operationId)))
-                fail("DEAL_MEMORY_UNVERIFIED", "indexed outcome memory is required");
+            if (next === "complete" && (this.get(operationId).evidence.payment !== "finalized" || this.get(operationId).evidence.delivery !== "verified"))
+                fail("DEAL_DELIVERY_UNVERIFIED", "finalized payment and verified delivery are required before deal completion");
             this.store.db.prepare("UPDATE deal_operations SET state=?,rail=COALESCE(?,rail),plan_hash=COALESCE(?,plan_hash),updated_at=? WHERE operation_id=?")
                 .run(next, result?.rail ?? null, result?.planHash ?? null, Date.now(), operationId);
             this.store.db.exec("COMMIT");

package/dist/demo.js

@@ -23,6 +23,7 @@ const value = (name, fallback) => typeof args[name] === "string" ? args[name] :
 const stateDir = () => resolve(value("state-dir", ".supercuts-demo"));
 const homes = (root) => ({ buyer: join(root, "buyer"), publicSeller: join(root, "public-seller"), secondPublicSeller: join(root, "second-public-seller"), confidentialSeller: join(root, "confidential-seller"), auditor: join(root, "auditor") });
 const send = (data) => process.stdout.write(`${JSON.stringify({ schemaVersion: "supercuts.demo.v1", ok: true, command, data })}\n`);
+const help = () => ({ commands: ["setup", "doctor", "seed-policy", "reuse-memories", "live", "replay", "check"], setup: "Run supercuts-demo setup --state-dir <owner-only-directory> with the pinned live configuration. Fund only the buyer address in funding[0].address.", live: "The live demo uses Sui Testnet and Mainnet-backed Walrus services; mock receipts are never settlement evidence." });
 function keyAddress(path) { const decoded = decodeSuiPrivateKey(readFileSync(path, "utf8").trim()); if (decoded.scheme !== "ED25519")
     fail("SIGNER_UNSUPPORTED", "demo requires ED25519 Sui keys"); return Ed25519Keypair.fromSecretKey(decoded.secretKey).toSuiAddress(); }
 function createKey(path) { if (!existsSync(path))
@@ -48,20 +49,51 @@ async function setup() {
             fail("DEMO_ROLE_PROFILE_MISMATCH", "demo setup needs fresh isolated live v2 role homes; choose a new --state-dir instead of reusing v1 or mock profiles");
     }
     const workflowPath = typeof args.workflow === "string" ? resolve(args.workflow) : !mock && typeof args["seller-url"] !== "string" ? resolve(value("workflow")) : undefined;
+    let activeCapabilities = [];
     if (workflowPath) {
-        const workflow = JSON.parse(readFileSync(workflowPath, "utf8")), capabilities = workflow.capabilities ?? [];
-        if (!capabilities.length)
+        const workflow = JSON.parse(readFileSync(workflowPath, "utf8")), configured = workflow.capabilities ?? [];
+        if (!configured.length)
             fail("DEMO_CAPABILITIES_REQUIRED", "live workflow must provide capability manifests for the buyer mandate");
-        for (const manifest of capabilities)
+        for (const manifest of configured)
             validateCapabilityManifest(manifest);
+        let capabilities = configured;
+        if (!mock && typeof args["seller-url"] === "string") {
+            const response = await fetch(new URL("/v1/catalog", new URL(args["seller-url"])), { signal: AbortSignal.timeout(90_000) });
+            if (!response.ok)
+                fail("SELLER_SERVICE_UNAVAILABLE", `remote seller catalog returned ${response.status}`);
+            const served = await response.json();
+            const allowedIds = new Set(configured.map((item) => item.capabilityId)), entries = (served.capabilities ?? []).filter((item) => item.manifest && allowedIds.has(item.manifest.capabilityId));
+            if (!entries.length || entries.some((item) => !item.manifest || typeof item.blobId !== "string"))
+                fail("SELLER_CATALOG_INVALID", "remote seller catalog has no configured capabilities with Walrus identities");
+            const app = new Phase3App(roles.buyer);
+            try {
+                const discovered = (await app.execute("capability.discover", { "blob-ids": Buffer.from(JSON.stringify(entries.map((item) => item.blobId))).toString("base64url") })).data.capabilities;
+                const verified = new Map(discovered.map((item) => [`${item.capabilityId}:${item.blobId}`, item.manifestHash]));
+                if (entries.some((item) => verified.get(`${item.manifest.capabilityId}:${item.blobId}`) !== item.manifest.manifestHash))
+                    fail("SELLER_CATALOG_INVALID", "remote seller catalog differs from its Walrus manifests");
+            }
+            finally {
+                app.close();
+            }
+            capabilities = entries.map((item) => item.manifest);
+        }
+        activeCapabilities = capabilities;
         const mandatePath = join(roles.buyer, "mandate.json"), mandate = JSON.parse(readFileSync(mandatePath, "utf8"));
         mandate.requireSettlementPlan = true;
         mandate.allowedCommands = [...new Set([...(Array.isArray(mandate.allowedCommands) ? mandate.allowedCommands : []), "settlement.plan"])];
+        mandate.allowedCounterparties = [...new Set(capabilities.map((item) => item.sellerId))];
         mandate.allowedCapabilityIds = [...new Set(capabilities.map((item) => item.capabilityId))];
         mandate.allowedCapabilityClasses = [...new Set(capabilities.map((item) => item.capability))];
         mandate.allowedRails = [...new Set(capabilities.flatMap((item) => item.supportedRails))];
         writeFileSync(mandatePath, `${JSON.stringify(mandate, null, 2)}\n`, { mode: 0o600 });
         chmodSync(mandatePath, 0o600);
+        const buyerProfilePath = join(roles.buyer, "profile.json"), buyerProfile = JSON.parse(readFileSync(buyerProfilePath, "utf8"));
+        if (!buyerProfile.policy)
+            fail("DEMO_ROLE_PROFILE_MISMATCH", "buyer profile has no payment policy");
+        const buyerPolicy = buyerProfile.policy;
+        buyerPolicy.allowedCounterparties = [...new Set(capabilities.map((item) => item.sellerId))];
+        writeFileSync(buyerProfilePath, `${JSON.stringify(buyerProfile, null, 2)}\n`, { mode: 0o600 });
+        chmodSync(buyerProfilePath, 0o600);
     }
     const mcpScript = join(dirname(fileURLToPath(import.meta.url)), "mcp.js");
     const mcp = { mcpServers: Object.fromEntries(Object.entries(roles).map(([name, home]) => [`supercuts-${name.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`)}`, { command: process.execPath, args: [mcpScript], env: { SUPERCUTS_HOME: home } }])) };
@@ -75,8 +107,10 @@ async function setup() {
         writeFileSync(join(root, "buyer-codex.toml"), codex, { mode: 0o600 });
     }
     const remote = typeof args["seller-url"] === "string";
-    writeFileSync(join(root, "run.json"), `${JSON.stringify({ schema: "supercuts.demo.run.v1", createdAt: new Date().toISOString(), runId, ...(remote ? { eventPath } : {}), mock, homes: roles, addresses }, null, 2)}\n`, { mode: 0o600 });
-    return { stateDir: root, mock, funding: mock ? [] : [{ address: addresses.buyer, needs: ["Testnet SUI gas", "configured x402 asset", "shielded deposit value"] }], sellerPayTo: addresses.publicSeller, sellerAddresses: { publicA: addresses.publicSeller, publicB: addresses.secondPublicSeller, analysis: addresses.confidentialSeller }, files: { mcp: join(root, "mcp.json"), run: join(root, "run.json"), events: remote ? eventPath : join(root, "events.jsonl"), ...(remote ? { codex: join(root, "buyer-codex.toml") } : {}) } };
+    writeFileSync(join(root, "run.json"), `${JSON.stringify({ schema: "supercuts.demo.run.v1", createdAt: new Date().toISOString(), runId, ...(remote ? { eventPath, sellerUrl: new URL(String(args["seller-url"])).toString() } : {}), mock, homes: roles, addresses }, null, 2)}\n`, { mode: 0o600 });
+    const publicSellers = activeCapabilities.filter((item) => item.capability === "sui.market-brief"), analysisSeller = activeCapabilities.find((item) => item.capability === "sui.competitor-analysis");
+    const settlementSellers = activeCapabilities.length ? { publicA: publicSellers[0]?.sellerId, publicB: publicSellers[1]?.sellerId, analysis: analysisSeller?.sellerId } : { publicA: addresses.publicSeller, publicB: addresses.secondPublicSeller, analysis: addresses.confidentialSeller };
+    return { stateDir: root, mock, funding: mock ? [] : [{ address: addresses.buyer, needs: ["Testnet SUI gas", "configured x402 asset", "shielded deposit value"] }], sellerPayTo: settlementSellers.publicA, sellerAddresses: settlementSellers, localRoleAddresses: { publicA: addresses.publicSeller, publicB: addresses.secondPublicSeller, analysis: addresses.confidentialSeller, auditor: addresses.auditor }, files: { mcp: join(root, "mcp.json"), run: join(root, "run.json"), events: remote ? eventPath : join(root, "events.jsonl"), ...(remote ? { codex: join(root, "buyer-codex.toml") } : {}) } };
 }
 async function doctor() {
     if (typeof args["buyer-home"] === "string") {
@@ -103,6 +137,11 @@ async function doctor() {
             const report = (await app.execute("doctor", {})).data;
             if (report.readyForDemo === false)
                 fail("DEMO_PREREQUISITES_MISSING", `${name}: ${report.fixes.join(" ")}`);
+            if (name === "buyer") {
+                const mandate = loadMandate(home), profileSellers = [...app.profile.policy.allowedCounterparties].sort(), mandateSellers = [...mandate.allowedCounterparties].sort();
+                if (JSON.stringify(profileSellers) !== JSON.stringify(mandateSellers))
+                    fail("POLICY_COUNTERPARTY_MISMATCH", "buyer mandate and payment profile allow different sellers; rerun setup refresh before funding");
+            }
             reports[name] = report;
         }
         finally {
@@ -114,16 +153,24 @@ async function doctor() {
         const base = new URL(args["seller-url"]), health = await fetch(new URL("/health", base), { signal: AbortSignal.timeout(90_000) }), catalog = await fetch(new URL("/v1/catalog", base), { signal: AbortSignal.timeout(30_000) });
         if (!health.ok || !catalog.ok)
             fail("SELLER_SERVICE_UNAVAILABLE", "remote seller health or catalog check failed");
+        const healthBody = await health.json(), buyerSigner = String(reports.buyer?.signer ?? ""), accessUrl = new URL("/v1/access", base);
+        accessUrl.searchParams.set("buyerAddress", buyerSigner);
+        const access = await fetch(accessUrl, { signal: AbortSignal.timeout(30_000) });
+        if (!access.ok)
+            fail("SELLER_SERVICE_UNAVAILABLE", "remote seller access preflight failed");
+        const accessBody = await access.json();
+        if (accessBody.allowed !== true)
+            fail("SELLER_BUYER_FORBIDDEN", "remote seller does not currently accept this buyer; use open access or complete owner enrollment before funding");
         const body = await catalog.json(), capabilities = body.capabilities ?? [];
         if (capabilities.filter((item) => item.manifest?.capability === "sui.market-brief").length < 2 || !capabilities.some((item) => item.manifest?.capability === "sui.competitor-analysis"))
             fail("SELLER_CATALOG_INVALID", "remote catalog needs two briefs and one competitor analysis");
-        remote = { healthy: true, origin: base.origin, capabilities: capabilities.length };
+        remote = { healthy: true, origin: base.origin, capabilities: capabilities.length, buyerAccess: accessBody.mode ?? healthBody.buyerAccess ?? "unknown", buyerAllowed: true };
     }
     return { healthy: true, roles: reports, isolation: new Set(Object.values(roles)).size === 5, ...(remote ? { remote } : {}) };
 }
 async function seedPolicy() {
     const source = JSON.parse(readFileSync(resolve(value("workflow")), "utf8"));
-    const manifest = source.capabilities?.find((item) => item.capability === "sui.competitor-analysis") ?? fail("DEMO_POLICY_SCOPE_INVALID", "workflow has no competitor analysis capability");
+    let manifest = source.capabilities?.find((item) => item.capability === "sui.competitor-analysis") ?? fail("DEMO_POLICY_SCOPE_INVALID", "workflow has no competitor analysis capability");
     validateCapabilityManifest(manifest);
     if (manifest.capability !== "sui.competitor-analysis")
         fail("DEMO_POLICY_SCOPE_INVALID", "privacy policy must target the competitor analysis capability");
@@ -131,6 +178,21 @@ async function seedPolicy() {
     try {
         if (app.profile.mock)
             fail("LIVE_PROFILE_REQUIRED", "saved demo privacy policy requires a live buyer profile");
+        const runPath = join(stateDir(), "run.json"), run = existsSync(runPath) ? JSON.parse(readFileSync(runPath, "utf8")) : {};
+        if (run.sellerUrl) {
+            const response = await fetch(new URL("/v1/catalog", run.sellerUrl), { signal: AbortSignal.timeout(90_000) });
+            if (!response.ok)
+                fail("SELLER_SERVICE_UNAVAILABLE", `remote seller catalog returned ${response.status}`);
+            const body = await response.json();
+            const entry = body.capabilities?.find((item) => item.manifest?.capabilityId === manifest.capabilityId && item.manifest.capability === "sui.competitor-analysis") ?? fail("DEMO_POLICY_SCOPE_INVALID", "remote catalog has no matching competitor analysis capability");
+            if (!entry.manifest || typeof entry.blobId !== "string")
+                fail("SELLER_CATALOG_INVALID", "remote analysis capability has no Walrus identity");
+            const liveManifest = entry.manifest, liveBlobId = entry.blobId;
+            const discovered = (await app.execute("capability.discover", { "blob-ids": Buffer.from(JSON.stringify([liveBlobId])).toString("base64url") })).data.capabilities;
+            if (discovered.length !== 1 || discovered[0].blobId !== liveBlobId || discovered[0].manifestHash !== liveManifest.manifestHash)
+                fail("SELLER_CATALOG_INVALID", "remote analysis capability differs from its Walrus manifest");
+            manifest = liveManifest;
+        }
         const memory = { version: "supercuts.settlement-memory.v1", kind: "privacy_rule", scope: { capabilityId: manifest.capabilityId, counterparty: manifest.sellerId, network: "sui:testnet", asset: manifest.asset }, createdAt: Date.now(), signal: { requiresShielded: true } };
         const parameters = { "operation-id": value("operation-id", `privacy-${manifest.capabilityId}`), memory: Buffer.from(JSON.stringify(memory)).toString("base64url") };
         const token = app.approve(app.preview("memory.policy", parameters).challengeId);
@@ -440,7 +502,7 @@ async function replay() {
     return { label: "recorded funded run", freshTransaction: false, events };
 }
 try {
-    const data = command === "setup" ? await setup() : command === "doctor" ? await doctor() : command === "seed-policy" ? await seedPolicy() : command === "reuse-memories" ? reuseMemories() : command === "check" ? await check() : command === "live" ? await live() : command === "replay" ? await replay() : fail("COMMAND_UNKNOWN", "use setup, doctor, seed-policy, reuse-memories, live, replay, or check");
+    const data = ["help", "--help", "-h"].includes(command) ? help() : command === "setup" ? await setup() : command === "doctor" ? await doctor() : command === "seed-policy" ? await seedPolicy() : command === "reuse-memories" ? reuseMemories() : command === "check" ? await check() : command === "live" ? await live() : command === "replay" ? await replay() : fail("COMMAND_UNKNOWN", "use setup, doctor, seed-policy, reuse-memories, live, replay, or check");
     send(data);
 }
 catch (error) {

package/dist/funding.d.ts

@@ -0,0 +1,38 @@
+export interface FundingPlan {
+    address: string;
+    publicBalanceMist: string;
+    shieldedBalanceMist: string;
+    publicPaymentMist: string;
+    shieldedPaymentMist: string;
+    gasReserveMist: string;
+    changeReserveMist: string;
+    poolDepositMist: string;
+    requiredPublicMist: string;
+    publicShortfallMist: string;
+    faucetRequired: boolean;
+    depositRequired: boolean;
+}
+export declare function calculateFundingPlan(input: {
+    address: string;
+    publicBalance: bigint;
+    shieldedBalance: bigint;
+    publicPayment: bigint;
+    shieldedPayment: bigint;
+    gasReserve: bigint;
+    changeReserve: bigint;
+}): FundingPlan;
+export declare function prepareFunding(home: string, values: {
+    publicPayment: string;
+    shieldedPayment: string;
+    gasReserve?: string;
+    changeReserve?: string;
+}): Promise<FundingPlan>;
+export declare function executeFunding(home: string, values: {
+    publicPayment: string;
+    shieldedPayment: string;
+    gasReserve?: string;
+    changeReserve?: string;
+    operationId: string;
+    requestFaucet: boolean;
+    confirmed: boolean;
+}): Promise<Record<string, unknown>>;

package/dist/funding.js

@@ -0,0 +1,78 @@
+import { execFileSync } from "node:child_process";
+import { createInterface } from "node:readline/promises";
+import { fail } from "./errors.js";
+import { Phase3App } from "./phase3.js";
+import { writeClient } from "./sui.js";
+const amount = (value, name) => /^[0-9]+$/.test(value) ? BigInt(value) : fail("FUNDING_INPUT_INVALID", `${name} must be unsigned MIST`);
+const POOL_DEPOSIT_DENOMINATIONS = [10000000n, 100000000n];
+const standardPoolDeposit = (shortfall) => {
+    if (shortfall === 0n)
+        return 0n;
+    const denomination = POOL_DEPOSIT_DENOMINATIONS.find((candidate) => candidate >= shortfall);
+    return denomination ?? fail("FUNDING_PLAN_UNSUPPORTED", `shielded funding needs ${shortfall} MIST, above the largest supported single deposit of ${POOL_DEPOSIT_DENOMINATIONS.at(-1)} MIST`);
+};
+export function calculateFundingPlan(input) {
+    const shieldedTarget = input.shieldedPayment > 0n ? input.shieldedPayment + input.changeReserve : 0n;
+    const poolShortfall = shieldedTarget > input.shieldedBalance ? shieldedTarget - input.shieldedBalance : 0n;
+    const poolDeposit = standardPoolDeposit(poolShortfall);
+    const requiredPublic = input.publicPayment + poolDeposit + input.gasReserve;
+    const publicShortfall = requiredPublic > input.publicBalance ? requiredPublic - input.publicBalance : 0n;
+    return { address: input.address, publicBalanceMist: input.publicBalance.toString(), shieldedBalanceMist: input.shieldedBalance.toString(), publicPaymentMist: input.publicPayment.toString(), shieldedPaymentMist: input.shieldedPayment.toString(), gasReserveMist: input.gasReserve.toString(), changeReserveMist: input.changeReserve.toString(), poolDepositMist: poolDeposit.toString(), requiredPublicMist: requiredPublic.toString(), publicShortfallMist: publicShortfall.toString(), faucetRequired: publicShortfall > 0n, depositRequired: poolDeposit > 0n };
+}
+export async function prepareFunding(home, values) {
+    const publicPayment = amount(values.publicPayment, "public payment"), shieldedPayment = amount(values.shieldedPayment, "shielded payment");
+    const gasReserve = amount(values.gasReserve ?? "100000000", "gas reserve"), changeReserve = amount(values.changeReserve ?? "1000000", "change reserve");
+    const app = new Phase3App(home);
+    try {
+        if (app.profile.role !== "buyer" || app.profile.mock)
+            fail("LIVE_PROFILE_REQUIRED", "funding requires a live buyer role home");
+        const doctor = await app.execute("doctor", {}), address = String(doctor.data.signer ?? "");
+        const endpoint = app.profile.live?.writeGrpcEndpoint ?? fail("LIVE_PROFILE_INVALID", "buyer write RPC is missing");
+        const [{ balance }, shielded] = await Promise.all([writeClient(endpoint).getBalance({ owner: address, coinType: "0x2::sui::SUI" }), app.execute("wallet.balance", {})]);
+        return calculateFundingPlan({ address, publicBalance: BigInt(balance.balance), shieldedBalance: BigInt(String(shielded.data.available ?? "0")), publicPayment, shieldedPayment, gasReserve, changeReserve });
+    }
+    finally {
+        app.close();
+    }
+}
+export async function executeFunding(home, values) {
+    if (!values.confirmed)
+        fail("FUNDING_CONFIRMATION_REQUIRED", "funding execution requires --confirm after reviewing the plan");
+    let plan = await prepareFunding(home, values);
+    if (plan.faucetRequired) {
+        if (!values.requestFaucet)
+            fail("BUYER_FUNDING_REQUIRED", `buyer needs ${plan.publicShortfallMist} additional MIST; rerun with --request-faucet --confirm or fund ${plan.address} manually`);
+        execFileSync("sui", ["client", "faucet", "--url", "https://faucet.testnet.sui.io", "--address", plan.address], { stdio: "inherit" });
+        for (let attempt = 0; attempt < 15; attempt++) {
+            await new Promise((resolve) => setTimeout(resolve, 2_000));
+            plan = await prepareFunding(home, values);
+            if (!plan.faucetRequired)
+                break;
+        }
+        if (plan.faucetRequired)
+            fail("FAUCET_ALLOCATION_INSUFFICIENT", `the public faucet allocation did not reach the required ${plan.requiredPublicMist} MIST; wait for finality and inspect funding status before requesting another allocation`);
+    }
+    if (!plan.depositRequired)
+        return { funded: true, faucetRequested: values.requestFaucet, deposit: "not-required", plan };
+    if (!values.operationId)
+        fail("ARGUMENT_REQUIRED", "funding execute requires --operation-id for safe retry");
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    try {
+        if (process.stdin.isTTY) {
+            const answer = (await rl.question(`Deposit ${plan.poolDepositMist} MIST into the experimental Testnet pool? type yes: `)).trim().toLowerCase();
+            if (answer !== "yes")
+                fail("FUNDING_CANCELLED", "pool deposit was not confirmed");
+        }
+    }
+    finally {
+        rl.close();
+    }
+    const app = new Phase3App(home);
+    try {
+        const deposit = await app.execute("wallet.deposit", { amount: plan.poolDepositMist, "operation-id": values.operationId, authorize: true });
+        return { funded: true, faucetRequested: values.requestFaucet, deposit: deposit.data, plan: await prepareFunding(home, values) };
+    }
+    finally {
+        app.close();
+    }
+}

package/dist/index.d.ts

@@ -15,6 +15,7 @@ export * from "./indexer.js";
 export * from "./memory.js";
 export * from "./settlement.js";
 export * from "./seller-runtime.js";
+export * from "./seller-research.js";
 export * from "./seller-stdio.js";
 export * from "./live-index.js";
 export * from "./live-runtime.js";

package/dist/index.js

@@ -15,6 +15,7 @@ export * from "./indexer.js";
 export * from "./memory.js";
 export * from "./settlement.js";
 export * from "./seller-runtime.js";
+export * from "./seller-research.js";
 export * from "./seller-stdio.js";
 export * from "./live-index.js";
 export * from "./live-runtime.js";

package/dist/live-deal-ports.js

@@ -64,7 +64,14 @@ export class LiveDealPorts {
         return Ed25519Keypair.fromSecretKey(decoded.secretKey);
     }
     async request(origin, path, body) {
-        const response = await this.http(new URL(path, origin), { ...(body ? { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) } : {}), redirect: "error", signal: AbortSignal.timeout(90_000) });
+        const url = new URL(path, origin);
+        let response;
+        try {
+            response = await this.http(url, { ...(body ? { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) } : {}), redirect: "error", signal: AbortSignal.timeout(90_000) });
+        }
+        catch (error) {
+            return fail("DEAL_SELLER_UNAVAILABLE", `seller ${url.origin} is unreachable; check its health endpoint and network route`, error);
+        }
         let value;
         try {
             value = await response.json();

package/dist/live-runtime.d.ts

@@ -5,6 +5,8 @@ import { Groth16Prover, type ProverConfig } from "./prover.js";
 import { type QueuedExit } from "./v2-exits.js";
 import { TatumLedger } from "./tatum.js";
 import type { RoleStore } from "./store.js";
+export declare function x402ResourceFailure(status: number, response: Uint8Array): string;
+export declare function timestampExpirationUnsupported(value: unknown): boolean;
 export interface LiveRuntimeProfile {
     role: "buyer" | "seller" | "auditor";
     packageId: string;
@@ -45,13 +47,14 @@ export declare class LiveRuntime {
     readonly prover: Groth16Prover;
     private constructor();
     static create(profile: LiveRuntimeProfile, store: RoleStore): Promise<LiveRuntime>;
-    doctor(): Promise<Record<string, unknown>>;
+    doctor(proofsRequired?: boolean): Promise<Record<string, unknown>>;
     balance(): Promise<Record<string, unknown>>;
     private signed;
     private operationContext;
     private existingSigned;
     private submit;
     private confirmTatum;
+    paymentStatus(operationId: string, reconcile?: boolean): Promise<Record<string, unknown>>;
     private prepareOpening;
     deposit(amount: bigint, operationId: string): Promise<Record<string, unknown>>;
     recover(): Promise<Record<string, unknown>>;