@garydevenay/emporion 0.0.2 → 0.0.3

package/dist/src/cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { AsyncLocalStorage } from "node:async_hooks";
 import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import { once } from "node:events";
 import { closeSync } from "node:fs";
 import { readFile } from "node:fs/promises";
@@ -13,6 +14,11 @@ import { loadPersistentIdentityMaterial } from "./persistent-agent.js";
 import * as Protocol from "./protocol/index.js";
 import { sha256Hex } from "./protocol/shared.js";
 import { TransportStorage } from "./storage.js";
+import { WalletService } from "./wallet/index.js";
+import { ContextStore } from "./context-store.js";
+import { DealsStore } from "./experience/deals-store.js";
+const DEFAULT_DAEMON_PROXY_TIMEOUT_MS = 5_000;
+const WALLET_DAEMON_PROXY_TIMEOUT_MS = 30_000;
 const DEFAULT_IO = {
     stdout(message) {
         process.stdout.write(message);
@@ -51,6 +57,12 @@ function parseArgs(argv) {
 function commandMatches(commandPath, ...expected) {
     return commandPath.length === expected.length && expected.every((value, index) => commandPath[index] === value);
 }
+function isContextCommand(commandPath) {
+    return commandPath[0] === "context";
+}
+function isWalletCommand(commandPath) {
+    return commandPath[0] === "wallet";
+}
 function getOptionValues(args, name) {
     return args.options.get(name) ?? [];
 }
@@ -92,6 +104,17 @@ function parseOptionalNonNegativeInteger(args, name) {
     const value = getOptionalOption(args, name);
     return value === undefined ? undefined : parseNonNegativeInteger(value, `--${name}`);
 }
+function parseOptionalIsoTimestamp(args, name) {
+    const value = getOptionalOption(args, name);
+    if (value === undefined) {
+        return undefined;
+    }
+    const epochMs = Date.parse(value);
+    if (Number.isNaN(epochMs)) {
+        throw new Error(`--${name} must be a valid ISO-8601 timestamp`);
+    }
+    return new Date(epochMs).toISOString();
+}
 function parseEnum(value, fieldName, allowed) {
     if (allowed.includes(value)) {
         return value;
@@ -193,16 +216,161 @@ function writeJson(io, value) {
 function normalizeDataDirPath(dataDir) {
     return path.resolve(dataDir);
 }
+function parsedArgsFromCommand(commandPath, options) {
+    const map = new Map();
+    for (const [name, value] of Object.entries(options)) {
+        if (value === undefined) {
+            continue;
+        }
+        if (typeof value === "boolean") {
+            if (value) {
+                map.set(name, ["true"]);
+            }
+            continue;
+        }
+        if (Array.isArray(value)) {
+            map.set(name, value.map((entry) => `${entry}`));
+            continue;
+        }
+        map.set(name, [`${value}`]);
+    }
+    return {
+        commandPath: [...commandPath],
+        options: map
+    };
+}
+async function runNestedCommand(commandPath, options) {
+    return executeCapturedInDaemon(parsedArgsFromCommand(commandPath, options));
+}
+function ensureObjectIdPrefix(objectId, prefixes) {
+    const trimmed = objectId.trim();
+    if (!prefixes.some((prefix) => trimmed.startsWith(prefix))) {
+        throw new Error(`Unsupported object id: ${trimmed}`);
+    }
+    return trimmed;
+}
+function stageOrder(stage) {
+    switch (stage) {
+        case "draft":
+            return 0;
+        case "negotiating":
+            return 1;
+        case "agreed":
+            return 2;
+        case "in_progress":
+            return 3;
+        case "proof_submitted":
+            return 4;
+        case "proof_accepted":
+            return 5;
+        case "settlement_pending":
+            return 6;
+        case "settled":
+            return 7;
+        case "closed":
+            return 8;
+    }
+}
+function stageAtLeast(current, expected) {
+    return stageOrder(current) >= stageOrder(expected);
+}
+function toChangedObjects(record) {
+    const entries = [];
+    if (record.rootObjectKind && record.rootObjectId)
+        entries.push({ kind: record.rootObjectKind, id: record.rootObjectId });
+    if (record.proposalKind && record.proposalId)
+        entries.push({ kind: record.proposalKind, id: record.proposalId });
+    if (record.agreementId)
+        entries.push({ kind: "agreement", id: record.agreementId });
+    if (record.contractId)
+        entries.push({ kind: "contract", id: record.contractId });
+    if (record.evidenceId)
+        entries.push({ kind: "evidence-bundle", id: record.evidenceId });
+    if (record.invoiceId)
+        entries.push({ kind: "invoice", id: record.invoiceId });
+    if (record.paymentId)
+        entries.push({ kind: "payment", id: record.paymentId });
+    return entries;
+}
+function nextActionsForStage(stage) {
+    switch (stage) {
+        case "draft":
+        case "negotiating":
+            return ["deal.propose", "deal.accept"];
+        case "agreed":
+            return ["deal.start"];
+        case "in_progress":
+            return ["proof.submit"];
+        case "proof_submitted":
+            return ["proof.accept"];
+        case "proof_accepted":
+            return ["settlement.invoice.create", "settlement.pay"];
+        case "settlement_pending":
+            return ["settlement.pay", "settlement.status"];
+        case "settled":
+            return ["deal.status"];
+        case "closed":
+            return [];
+    }
+}
+function writeDealResponse(io, command, deal, overrides) {
+    writeJson(io, {
+        command,
+        dealId: deal.dealId,
+        stage: deal.stage,
+        changedObjects: toChangedObjects(deal),
+        nextActions: nextActionsForStage(deal.stage),
+        safety: {
+            policy: "proof-gated",
+            earlySettlementAllowed: overrides?.safety?.earlySettlementAllowed ?? false
+        }
+    });
+}
+function asRecord(value, label) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error(`Expected ${label} to be an object`);
+    }
+    return value;
+}
+function readString(value, fieldName) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`Expected ${fieldName} to be a non-empty string`);
+    }
+    return value;
+}
+function inferIntentFromRootObjectKind(kind) {
+    return kind === "request" ? "sell" : "buy";
+}
+function inferRootObjectKindFromId(objectId) {
+    if (objectId.startsWith("emporion:request:")) {
+        return "request";
+    }
+    if (objectId.startsWith("emporion:listing:")) {
+        return "listing";
+    }
+    throw new Error(`Unsupported target object id for proposal: ${objectId}`);
+}
+function inferProposalKindFromId(proposalId) {
+    if (proposalId.startsWith("emporion:offer:")) {
+        return "offer";
+    }
+    if (proposalId.startsWith("emporion:bid:")) {
+        return "bid";
+    }
+    throw new Error(`Unsupported proposal id: ${proposalId}`);
+}
 async function openCliContext(dataDir) {
     const identityMaterial = await loadPersistentIdentityMaterial(dataDir);
     const repository = await Protocol.ProtocolRepository.create(dataDir);
     const transportStorage = await TransportStorage.create(dataDir, identityMaterial.storagePrimaryKey, createLogger("error"));
+    const walletService = await WalletService.create({ dataDir });
     await transportStorage.initializeDefaults();
     return {
         dataDir,
         identityMaterial,
         repository,
         transportStorage,
+        walletService,
         signer: {
             did: identityMaterial.agentIdentity.did,
             publicKey: identityMaterial.transportKeyPair.publicKey,
@@ -211,6 +379,7 @@ async function openCliContext(dataDir) {
     };
 }
 async function closeCliContext(context) {
+    await context.walletService.close();
     await context.transportStorage.close();
     await context.repository.close();
 }
@@ -224,7 +393,7 @@ async function withCliContext(dataDir, fn) {
     }
     const context = await openCliContext(dataDir);
     try {
-        return await fn(context);
+        return await CLI_CONTEXT_STORAGE.run(context, async () => fn(context));
     }
     finally {
         await closeCliContext(context);
@@ -1770,11 +1939,640 @@ async function handleMarketList(args, io) {
         });
     });
 }
+async function handleContextAdd(args, io) {
+    const name = requireOption(args, "name");
+    const dataDir = requireOption(args, "data-dir");
+    const makeActive = hasFlag(args, "make-active");
+    const store = new ContextStore();
+    const snapshot = await store.add(name, dataDir, makeActive);
+    writeJson(io, {
+        command: "context.add",
+        activeContext: snapshot.activeContext,
+        contexts: snapshot.contexts
+    });
+}
+async function handleContextUse(args, io) {
+    const name = requireOption(args, "name");
+    const store = new ContextStore();
+    const snapshot = await store.use(name);
+    writeJson(io, {
+        command: "context.use",
+        activeContext: snapshot.activeContext,
+        contexts: snapshot.contexts
+    });
+}
+async function handleContextList(io) {
+    const store = new ContextStore();
+    const snapshot = await store.snapshot();
+    writeJson(io, {
+        command: "context.list",
+        activeContext: snapshot.activeContext,
+        contexts: snapshot.contexts
+    });
+}
+async function handleContextShow(io) {
+    const store = new ContextStore();
+    const snapshot = await store.snapshot();
+    const active = snapshot.activeContext
+        ? snapshot.contexts.find((entry) => entry.name === snapshot.activeContext)
+        : undefined;
+    writeJson(io, {
+        command: "context.show",
+        activeContext: snapshot.activeContext,
+        active: active ?? null
+    });
+}
+async function handleContextRemove(args, io) {
+    const name = requireOption(args, "name");
+    const store = new ContextStore();
+    const snapshot = await store.remove(name);
+    writeJson(io, {
+        command: "context.remove",
+        activeContext: snapshot.activeContext,
+        contexts: snapshot.contexts
+    });
+}
+function applyWalletRuntimeKeyFromArgs(context, args) {
+    const walletKey = getOptionalOption(args, "wallet-key");
+    if (walletKey && walletKey.trim().length > 0) {
+        context.walletService.setRuntimeKey(walletKey);
+    }
+}
+async function handleWalletConnectNwc(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const connectionUri = requireOption(args, "connection-uri");
+    const publishEndpoint = hasFlag(args, "publish-payment-endpoint");
+    await withCliContext(dataDir, async (context) => {
+        applyWalletRuntimeKeyFromArgs(context, args);
+        const connected = await context.walletService.connect(connectionUri);
+        let paymentEndpointEventId;
+        if (publishEndpoint) {
+            await ensureAgentProfileExists(context);
+            const capabilities = getCsvOptionValues(args, "payment-capability");
+            const accountId = getOptionalOption(args, "payment-account-id");
+            const endpoint = {
+                id: getOptionalOption(args, "payment-endpoint-id") ?? "wallet-nwc",
+                network: "bitcoin",
+                custodial: true,
+                capabilities: capabilities.length > 0 ? capabilities : ["invoice.create", "invoice.pay", "auto-settle"],
+                ...(accountId ? { accountId } : {}),
+                nodeUri: connected.endpoint
+            };
+            const result = await appendEnvelope(context, {
+                objectKind: "agent-profile",
+                objectId: context.identityMaterial.agentIdentity.did,
+                eventKind: "agent-profile.payment-endpoint-added",
+                subjectId: context.identityMaterial.agentIdentity.did,
+                payload: Protocol.paymentEndpointToJson(endpoint)
+            });
+            paymentEndpointEventId = result.envelope.eventId;
+        }
+        writeJson(io, {
+            command: "wallet.connect.nwc",
+            wallet: connected.status,
+            endpoint: connected.endpoint,
+            ...(paymentEndpointEventId ? { paymentEndpointEventId } : {})
+        });
+    });
+}
+async function handleWalletDisconnect(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    await withCliContext(dataDir, async (context) => {
+        applyWalletRuntimeKeyFromArgs(context, args);
+        const wallet = await context.walletService.disconnect();
+        writeJson(io, {
+            command: "wallet.disconnect",
+            wallet
+        });
+    });
+}
+async function handleWalletStatus(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    await withCliContext(dataDir, async (context) => {
+        applyWalletRuntimeKeyFromArgs(context, args);
+        writeJson(io, {
+            command: "wallet.status",
+            wallet: await context.walletService.status()
+        });
+    });
+}
+async function handleWalletUnlock(args, io) {
+    if (process.env.EMPORION_DAEMON !== "1") {
+        throw new Error("wallet unlock requires a running daemon for this data-dir");
+    }
+    const dataDir = requireOption(args, "data-dir");
+    const walletKey = requireOption(args, "wallet-key");
+    if (walletKey.trim().length === 0) {
+        throw new Error("--wallet-key must not be blank");
+    }
+    await withCliContext(dataDir, async (context) => {
+        context.walletService.setRuntimeKey(walletKey);
+        writeJson(io, {
+            command: "wallet.unlock",
+            wallet: await context.walletService.status()
+        });
+    });
+}
+async function handleWalletLock(args, io) {
+    if (process.env.EMPORION_DAEMON !== "1") {
+        throw new Error("wallet lock requires a running daemon for this data-dir");
+    }
+    const dataDir = requireOption(args, "data-dir");
+    await withCliContext(dataDir, async (context) => {
+        context.walletService.setRuntimeKey(null);
+        writeJson(io, {
+            command: "wallet.lock",
+            wallet: await context.walletService.status()
+        });
+    });
+}
+async function handleWalletInvoiceCreate(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const amountSats = parsePositiveInteger(requireOption(args, "amount-sats"), "--amount-sats");
+    const memo = getOptionalOption(args, "memo");
+    const expiresAt = parseOptionalIsoTimestamp(args, "expires-at");
+    await withCliContext(dataDir, async (context) => {
+        applyWalletRuntimeKeyFromArgs(context, args);
+        const created = await context.walletService.createInvoice({
+            amountSats,
+            ...(memo ? { memo } : {}),
+            ...(expiresAt ? { expiresAt } : {})
+        });
+        writeJson(io, {
+            command: "wallet.invoice.create",
+            invoice: created.invoice,
+            bolt11: created.bolt11
+        });
+    });
+}
+async function handleWalletPayBolt11(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const invoice = requireOption(args, "invoice");
+    const sourceRef = getOptionalOption(args, "source-ref");
+    await withCliContext(dataDir, async (context) => {
+        applyWalletRuntimeKeyFromArgs(context, args);
+        const paid = await context.walletService.payInvoice({
+            invoice,
+            ...(sourceRef ? { sourceRef } : {})
+        });
+        writeJson(io, {
+            command: "wallet.pay.bolt11",
+            payment: paid.payment
+        });
+    });
+}
+async function handleWalletLedgerList(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const kindValue = getOptionalOption(args, "kind");
+    const status = getOptionalOption(args, "status");
+    const kind = kindValue ? parseEnum(kindValue, "--kind", ["invoice", "payment"]) : undefined;
+    await withCliContext(dataDir, async (context) => {
+        applyWalletRuntimeKeyFromArgs(context, args);
+        const filters = {
+            ...(kind ? { kind } : {}),
+            ...(status ? { status } : {})
+        };
+        writeJson(io, {
+            command: "wallet.ledger.list",
+            kind: kind ?? null,
+            status: status ?? null,
+            entries: await context.walletService.listLedger(filters)
+        });
+    });
+}
+async function handleWalletKeyRotate(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const newKey = requireOption(args, "new-key");
+    await withCliContext(dataDir, async (context) => {
+        applyWalletRuntimeKeyFromArgs(context, args);
+        await context.walletService.rotateKey(newKey);
+        writeJson(io, {
+            command: "wallet.key.rotate",
+            rotated: true
+        });
+    });
+}
+async function handleDealOpen(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const intent = parseEnum(requireOption(args, "intent"), "--intent", ["buy", "sell"]);
+    const marketplaceId = requireOption(args, "marketplace");
+    const title = requireOption(args, "title");
+    const amountSats = parsePositiveInteger(requireOption(args, "amount-sats"), "--amount-sats");
+    const dealId = getOptionalOption(args, "deal-id") ?? `deal:${randomUUID()}`;
+    await withCliContext(dataDir, async () => {
+        const deals = await DealsStore.create(dataDir);
+        if (deals.get(dealId)) {
+            throw new Error(`Deal already exists: ${dealId}`);
+        }
+        const created = await runNestedCommand(["market", intent === "buy" ? "request" : "listing", "publish"], {
+            "data-dir": dataDir,
+            marketplace: marketplaceId,
+            title,
+            "amount-sats": `${amountSats}`
+        });
+        const createdRecord = asRecord(created, `${intent}.publish result`);
+        const objectId = readString(createdRecord.objectId, "objectId");
+        const nowIso = now();
+        const deal = {
+            dealId,
+            stage: "negotiating",
+            intent,
+            marketplaceId,
+            title,
+            amountSats,
+            rootObjectKind: intent === "buy" ? "request" : "listing",
+            rootObjectId: objectId,
+            createdAt: nowIso,
+            updatedAt: nowIso
+        };
+        await deals.save(deal);
+        writeDealResponse(io, "deal.open", deal);
+    });
+}
+async function handleDealPropose(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const targetId = requireOption(args, "target-id");
+    const amountSats = parsePositiveInteger(requireOption(args, "amount-sats"), "--amount-sats");
+    const proposalId = getOptionalOption(args, "proposal-id");
+    const proposerDid = getOptionalOption(args, "proposer-did");
+    await withCliContext(dataDir, async (context) => {
+        const rootObjectKind = inferRootObjectKindFromId(targetId);
+        const deals = await DealsStore.create(dataDir);
+        const targetState = rootObjectKind === "request"
+            ? await readRequiredState(context.repository, "request", targetId)
+            : await readRequiredState(context.repository, "listing", targetId);
+        const proposalKind = rootObjectKind === "request" ? "offer" : "bid";
+        const proposed = await runNestedCommand(["market", proposalKind, "submit"], {
+            "data-dir": dataDir,
+            marketplace: targetState.marketplaceId,
+            "target-object-id": targetId,
+            "amount-sats": `${amountSats}`,
+            ...(proposerDid ? { "proposer-did": proposerDid } : {}),
+            ...(proposalId ? { id: proposalId } : {})
+        });
+        const proposedRecord = asRecord(proposed, `${proposalKind}.submit result`);
+        const resolvedProposalId = readString(proposedRecord.objectId, "objectId");
+        const existing = deals.findByRootObjectId(targetId);
+        const nowIso = now();
+        const deal = existing
+            ? await deals.update(existing.dealId, (current) => ({
+                ...current,
+                stage: "negotiating",
+                proposalKind,
+                proposalId: resolvedProposalId,
+                amountSats,
+                updatedAt: nowIso
+            }))
+            : await deals.save({
+                dealId: `deal:${randomUUID()}`,
+                stage: "negotiating",
+                intent: inferIntentFromRootObjectKind(rootObjectKind),
+                marketplaceId: targetState.marketplaceId,
+                title: "proposal-only-deal",
+                amountSats,
+                rootObjectKind,
+                rootObjectId: targetId,
+                proposalKind,
+                proposalId: resolvedProposalId,
+                createdAt: nowIso,
+                updatedAt: nowIso
+            });
+        writeDealResponse(io, "deal.propose", deal);
+    });
+}
+async function handleDealAccept(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const proposalId = requireOption(args, "proposal-id");
+    const proposalKind = inferProposalKindFromId(proposalId);
+    await withCliContext(dataDir, async () => {
+        const deals = await DealsStore.create(dataDir);
+        await runNestedCommand(["market", proposalKind, "accept"], {
+            "data-dir": dataDir,
+            id: proposalId
+        });
+        const existing = deals.findByProposalId(proposalId);
+        const nowIso = now();
+        const deal = existing
+            ? await deals.update(existing.dealId, (current) => ({
+                ...current,
+                stage: "agreed",
+                proposalKind,
+                proposalId,
+                updatedAt: nowIso
+            }))
+            : await deals.save({
+                dealId: `deal:${randomUUID()}`,
+                stage: "agreed",
+                proposalKind,
+                proposalId,
+                createdAt: nowIso,
+                updatedAt: nowIso
+            });
+        writeDealResponse(io, "deal.accept", deal);
+    });
+}
+async function handleDealStart(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const proposalId = requireOption(args, "proposal-id");
+    const scope = requireOption(args, "scope");
+    const milestoneId = requireOption(args, "milestone-id");
+    const milestoneTitle = requireOption(args, "milestone-title");
+    const deadline = parseOptionalIsoTimestamp(args, "deadline");
+    if (!deadline) {
+        throw new Error("--deadline is required");
+    }
+    const deliverableKind = parseEnum(requireOption(args, "deliverable-kind"), "--deliverable-kind", ["artifact", "generic", "oracle-claim"]);
+    const requiredArtifactKinds = getCsvOptionValues(args, "required-artifact-kind");
+    if (requiredArtifactKinds.length === 0) {
+        throw new Error("--required-artifact-kind must include at least one value");
+    }
+    const proposalKind = inferProposalKindFromId(proposalId);
+    await withCliContext(dataDir, async (context) => {
+        const deals = await DealsStore.create(dataDir);
+        const proposalState = proposalKind === "offer"
+            ? await readRequiredState(context.repository, "offer", proposalId)
+            : await readRequiredState(context.repository, "bid", proposalId);
+        if (proposalState.status !== "accepted") {
+            throw new Error(`Proposal must be accepted before deal start: ${proposalId}`);
+        }
+        const agreement = await runNestedCommand(["market", "agreement", "create"], {
+            "data-dir": dataDir,
+            "source-kind": proposalKind,
+            "source-id": proposalId,
+            deliverable: [milestoneTitle],
+            counterparty: [context.identityMaterial.agentIdentity.did, proposalState.proposerDid],
+            "amount-sats": `${proposalState.paymentTerms.amountSats}`
+        });
+        const agreementRecord = asRecord(agreement, "agreement.create result");
+        const agreementId = readString(agreementRecord.objectId, "objectId");
+        const milestonesJson = JSON.stringify([{
+                milestoneId,
+                title: milestoneTitle,
+                deliverableSchema: {
+                    kind: deliverableKind,
+                    requiredArtifactKinds
+                },
+                proofPolicy: {
+                    allowedModes: ["artifact-verifiable"],
+                    verifierRefs: [],
+                    minArtifacts: 1,
+                    requireCounterpartyAcceptance: true
+                },
+                settlementAdapters: []
+            }]);
+        const contract = await runNestedCommand(["contract", "create"], {
+            "data-dir": dataDir,
+            "origin-kind": "agreement",
+            "origin-id": agreementId,
+            party: [context.identityMaterial.agentIdentity.did, proposalState.proposerDid],
+            scope,
+            "milestones-json": milestonesJson,
+            "deliverable-schema-json": JSON.stringify({ kind: deliverableKind, requiredArtifactKinds }),
+            "proof-policy-json": JSON.stringify({
+                allowedModes: ["artifact-verifiable"],
+                verifierRefs: [],
+                minArtifacts: 1,
+                requireCounterpartyAcceptance: true
+            }),
+            "resolution-policy-json": JSON.stringify({ mode: "mutual", deterministicVerifierIds: [] }),
+            "settlement-policy-json": JSON.stringify({ adapters: [], releaseCondition: "contract-completed" }),
+            "deadline-policy-json": JSON.stringify({ milestoneDeadlines: { [milestoneId]: deadline } })
+        });
+        const contractRecord = asRecord(contract, "contract.create result");
+        const contractId = readString(contractRecord.objectId, "objectId");
+        await runNestedCommand(["contract", "open-milestone"], {
+            "data-dir": dataDir,
+            id: contractId,
+            "milestone-id": milestoneId
+        });
+        const existing = deals.findByProposalId(proposalId);
+        const nowIso = now();
+        const deal = existing
+            ? await deals.update(existing.dealId, (current) => ({
+                ...current,
+                stage: "in_progress",
+                proposalKind,
+                proposalId,
+                agreementId,
+                contractId,
+                milestoneId,
+                updatedAt: nowIso
+            }))
+            : await deals.save({
+                dealId: `deal:${randomUUID()}`,
+                stage: "in_progress",
+                proposalKind,
+                proposalId,
+                agreementId,
+                contractId,
+                milestoneId,
+                createdAt: nowIso,
+                updatedAt: nowIso
+            });
+        writeDealResponse(io, "deal.start", deal);
+    });
+}
+async function handleDealStatus(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const dealId = requireOption(args, "deal-id");
+    const deals = await DealsStore.create(dataDir);
+    const deal = deals.get(dealId);
+    if (!deal) {
+        throw new Error(`Unknown deal: ${dealId}`);
+    }
+    writeDealResponse(io, "deal.status", deal);
+}
+async function handleProofSubmit(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const dealId = requireOption(args, "deal-id");
+    const milestoneId = requireOption(args, "milestone-id");
+    const preset = parseEnum(requireOption(args, "proof-preset"), "--proof-preset", ["simple-artifact"]);
+    if (preset !== "simple-artifact") {
+        throw new Error(`Unsupported --proof-preset: ${preset}`);
+    }
+    const artifactId = requireOption(args, "artifact-id");
+    const artifactHash = requireOption(args, "artifact-hash");
+    const repro = getOptionalOption(args, "repro");
+    await withCliContext(dataDir, async () => {
+        const deals = await DealsStore.create(dataDir);
+        const existing = deals.get(dealId);
+        if (!existing) {
+            throw new Error(`Unknown deal: ${dealId}`);
+        }
+        if (!existing.contractId) {
+            throw new Error("Deal has no contract yet; run deal start first");
+        }
+        if (!stageAtLeast(existing.stage, "in_progress")) {
+            throw new Error("Deal is not ready for proof submission");
+        }
+        const evidence = await runNestedCommand(["evidence", "record"], {
+            "data-dir": dataDir,
+            "contract-id": existing.contractId,
+            "milestone-id": milestoneId,
+            "proof-mode": "artifact-verifiable",
+            "artifact-json": JSON.stringify([{ artifactId, hash: artifactHash }]),
+            "verifier-json": JSON.stringify([{ verifierId: "simple-artifact-check", verifierKind: "human-review" }]),
+            ...(repro ? { repro } : {})
+        });
+        const evidenceRecord = asRecord(evidence, "evidence.record result");
+        const evidenceId = readString(evidenceRecord.objectId, "objectId");
+        await runNestedCommand(["contract", "submit-milestone"], {
+            "data-dir": dataDir,
+            id: existing.contractId,
+            "milestone-id": milestoneId,
+            "evidence-bundle-id": evidenceId
+        });
+        const nowIso = now();
+        const deal = await deals.update(dealId, (current) => ({
+            ...current,
+            stage: "proof_submitted",
+            milestoneId,
+            evidenceId,
+            updatedAt: nowIso
+        }));
+        writeDealResponse(io, "proof.submit", deal);
+    });
+}
+async function handleProofAccept(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const dealId = requireOption(args, "deal-id");
+    const milestoneId = requireOption(args, "milestone-id");
+    await withCliContext(dataDir, async () => {
+        const deals = await DealsStore.create(dataDir);
+        const existing = deals.get(dealId);
+        if (!existing) {
+            throw new Error(`Unknown deal: ${dealId}`);
+        }
+        if (!existing.contractId) {
+            throw new Error("Deal has no contract yet");
+        }
+        if (!stageAtLeast(existing.stage, "proof_submitted")) {
+            throw new Error("Deal proof must be submitted before acceptance");
+        }
+        await runNestedCommand(["contract", "accept-milestone"], {
+            "data-dir": dataDir,
+            id: existing.contractId,
+            "milestone-id": milestoneId
+        });
+        const nowIso = now();
+        const deal = await deals.update(dealId, (current) => ({
+            ...current,
+            stage: "proof_accepted",
+            milestoneId,
+            updatedAt: nowIso
+        }));
+        writeDealResponse(io, "proof.accept", deal);
+    });
+}
+async function handleSettlementInvoiceCreate(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const dealId = requireOption(args, "deal-id");
+    const amountSats = parsePositiveInteger(requireOption(args, "amount-sats"), "--amount-sats");
+    const memo = getOptionalOption(args, "memo");
+    const expiresAt = parseOptionalIsoTimestamp(args, "expires-at");
+    const allowEarlySettlement = hasFlag(args, "allow-early-settlement");
+    await withCliContext(dataDir, async (context) => {
+        const deals = await DealsStore.create(dataDir);
+        const existing = deals.get(dealId);
+        if (!existing) {
+            throw new Error(`Unknown deal: ${dealId}`);
+        }
+        if (!allowEarlySettlement && !stageAtLeast(existing.stage, "proof_accepted")) {
+            throw new Error("Settlement invoice creation is proof-gated. Use --allow-early-settlement to override.");
+        }
+        applyWalletRuntimeKeyFromArgs(context, args);
+        const created = await context.walletService.createInvoice({
+            amountSats,
+            ...(memo ? { memo } : {}),
+            ...(expiresAt ? { expiresAt } : {})
+        });
+        const nowIso = now();
+        const deal = await deals.update(dealId, (current) => ({
+            ...current,
+            stage: "settlement_pending",
+            invoiceId: created.invoice.id,
+            invoiceBolt11: created.bolt11,
+            updatedAt: nowIso
+        }));
+        writeDealResponse(io, "settlement.invoice.create", deal, {
+            safety: { earlySettlementAllowed: allowEarlySettlement }
+        });
+    });
+}
+async function handleSettlementPay(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const dealId = requireOption(args, "deal-id");
+    const invoice = requireOption(args, "invoice");
+    const allowEarlySettlement = hasFlag(args, "allow-early-settlement");
+    await withCliContext(dataDir, async (context) => {
+        const deals = await DealsStore.create(dataDir);
+        const existing = deals.get(dealId);
+        if (!existing) {
+            throw new Error(`Unknown deal: ${dealId}`);
+        }
+        if (!allowEarlySettlement && !stageAtLeast(existing.stage, "proof_accepted")) {
+            throw new Error("Settlement payment is proof-gated. Use --allow-early-settlement to override.");
+        }
+        applyWalletRuntimeKeyFromArgs(context, args);
+        const sourceRef = existing.contractId
+            ? `${existing.contractId}:${existing.milestoneId ?? "milestone"}`
+            : dealId;
+        const paid = await context.walletService.payInvoice({
+            invoice,
+            sourceRef
+        });
+        const nowIso = now();
+        const deal = await deals.update(dealId, (current) => ({
+            ...current,
+            stage: "settled",
+            paymentId: paid.payment.id,
+            updatedAt: nowIso
+        }));
+        writeDealResponse(io, "settlement.pay", deal, {
+            safety: { earlySettlementAllowed: allowEarlySettlement }
+        });
+    });
+}
+async function handleSettlementStatus(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const dealId = requireOption(args, "deal-id");
+    const deals = await DealsStore.create(dataDir);
+    const deal = deals.get(dealId);
+    if (!deal) {
+        throw new Error(`Unknown deal: ${dealId}`);
+    }
+    writeDealResponse(io, "settlement.status", deal);
+}
 function usage() {
     return [
         "Usage:",
+        "  Global data-dir resolution: --data-dir <path> > --context <name> > active context",
+        "  emporion context add --name <context> --data-dir <path> [--make-active]",
+        "  emporion context use --name <context>",
+        "  emporion context list",
+        "  emporion context show",
+        "  emporion context remove --name <context>",
         "  emporion agent init --data-dir <path> [--display-name <name>] [--bio <text>]",
         "  emporion agent show --data-dir <path>",
+        "  emporion wallet connect nwc --data-dir <path> --connection-uri <uri> [--publish-payment-endpoint]",
+        "  emporion wallet disconnect --data-dir <path>",
+        "  emporion wallet status --data-dir <path>",
+        "  emporion wallet unlock [--data-dir <path>|--context <name>] --wallet-key <key-material>",
+        "  emporion wallet lock [--data-dir <path>|--context <name>]",
+        "  emporion wallet invoice create --data-dir <path> --amount-sats <n> [--memo <text>] [--expires-at <iso>]",
+        "  emporion wallet pay bolt11 --data-dir <path> --invoice <bolt11>",
+        "  emporion wallet ledger list --data-dir <path> [--kind <invoice|payment>] [--status <status>]",
+        "  emporion wallet key rotate --data-dir <path> --new-key <key-material>",
+        "  emporion deal open [--data-dir <path>|--context <name>] --intent <buy|sell> --marketplace <id> --title <text> --amount-sats <n> [--deal-id <id>]",
+        "  emporion deal propose [--data-dir <path>|--context <name>] --target-id <object-id> --amount-sats <n> [--proposal-id <id>] [--proposer-did <did>]",
+        "  emporion deal accept [--data-dir <path>|--context <name>] --proposal-id <offer-or-bid-id>",
+        "  emporion deal start [--data-dir <path>|--context <name>] --proposal-id <offer-or-bid-id> --scope <text> --milestone-id <id> --milestone-title <text> --deadline <iso> --deliverable-kind <artifact|generic|oracle-claim> --required-artifact-kind <kind>[,<kind>...]",
+        "  emporion deal status [--data-dir <path>|--context <name>] --deal-id <id>",
+        "  emporion proof submit [--data-dir <path>|--context <name>] --deal-id <id> --milestone-id <id> --proof-preset <simple-artifact> --artifact-id <id> --artifact-hash <hex> [--repro <text>]",
+        "  emporion proof accept [--data-dir <path>|--context <name>] --deal-id <id> --milestone-id <id>",
+        "  emporion settlement invoice create [--data-dir <path>|--context <name>] --deal-id <id> --amount-sats <n> [--memo <text>] [--expires-at <iso>]",
+        "  emporion settlement pay [--data-dir <path>|--context <name>] --deal-id <id> --invoice <bolt11>",
+        "  emporion settlement status [--data-dir <path>|--context <name>] --deal-id <id>",
         "  emporion agent payment-endpoint add --data-dir <path> --id <id> --capability <cap>[,<cap>...]",
         "  emporion agent wallet-attestation add --data-dir <path> --attestation-id <id> --wallet-account-id <id> --balance-sats <n> --expires-at <iso>",
         "  emporion agent feedback add --data-dir <path> --credential-id <id> --issuer-did <did> --contract-id <id> --agreement-id <id> --score <n> --max-score <n>",
@@ -1805,6 +2603,53 @@ function usage() {
 function getDataDirFromArgs(args) {
     return getOptionalOption(args, "data-dir");
 }
+async function withResolvedDataDir(args) {
+    if (isContextCommand(args.commandPath)) {
+        return args;
+    }
+    if (getOptionalOption(args, "data-dir")) {
+        return args;
+    }
+    const requestedContext = getOptionalOption(args, "context");
+    const store = new ContextStore();
+    const resolved = await store.resolveDataDir(requestedContext);
+    if (requestedContext && !resolved) {
+        throw new Error(`Unknown context: ${requestedContext}`);
+    }
+    if (!resolved) {
+        return args;
+    }
+    const options = new Map(args.options);
+    options.set("data-dir", [resolved]);
+    return {
+        commandPath: [...args.commandPath],
+        options
+    };
+}
+function withDaemonWalletKeyForwarding(args) {
+    if (!isWalletCommand(args.commandPath)) {
+        return args;
+    }
+    if (getOptionalOption(args, "wallet-key")) {
+        return args;
+    }
+    const walletKey = process.env.EMPORION_WALLET_KEY;
+    if (!walletKey || walletKey.trim().length === 0) {
+        return args;
+    }
+    const options = new Map(args.options);
+    options.set("wallet-key", [walletKey]);
+    return {
+        commandPath: [...args.commandPath],
+        options
+    };
+}
+function getDaemonProxyTimeoutMs(commandPath) {
+    if (isWalletCommand(commandPath) || commandPath[0] === "settlement") {
+        return WALLET_DAEMON_PROXY_TIMEOUT_MS;
+    }
+    return DEFAULT_DAEMON_PROXY_TIMEOUT_MS;
+}
 function createCaptureIo() {
     const stdout = [];
     const stderr = [];
@@ -1944,7 +2789,7 @@ async function proxyParsedArgsToDaemon(args, io) {
     if (!dataDir) {
         return 1;
     }
-    const response = await sendDaemonCommand(dataDir, daemonRequestFromParsed(args.commandPath, daemonRequestOptionsToRecord(args.options)));
+    const response = await sendDaemonCommand(dataDir, daemonRequestFromParsed(args.commandPath, daemonRequestOptionsToRecord(args.options)), getDaemonProxyTimeoutMs(args.commandPath));
     if (!response.ok) {
         throw new Error(response.error ?? "Daemon command failed");
     }
@@ -2088,7 +2933,7 @@ async function handleDaemonLogs(args, io) {
         process.off("SIGTERM", stop);
     }
 }
-async function buildDaemonSharedContext(dataDir, transport) {
+async function buildDaemonSharedContext(dataDir, transport, walletService) {
     const identityMaterial = transport.getIdentityMaterial();
     const repository = await Protocol.ProtocolRepository.create(dataDir);
     return {
@@ -2096,6 +2941,7 @@ async function buildDaemonSharedContext(dataDir, transport) {
         identityMaterial,
         repository,
         transportStorage: transport.getStorage(),
+        walletService,
         signer: {
             did: identityMaterial.agentIdentity.did,
             publicKey: identityMaterial.transportKeyPair.publicKey,
@@ -2103,7 +2949,7 @@ async function buildDaemonSharedContext(dataDir, transport) {
         }
     };
 }
-function buildDaemonStatus(dataDir, startedAt, transport) {
+function buildDaemonStatus(dataDir, startedAt, transport, walletStatus) {
     return {
         dataDir: normalizeDataDirPath(dataDir),
         pid: process.pid,
@@ -2113,9 +2959,56 @@ function buildDaemonStatus(dataDir, startedAt, transport) {
         logPath: getDaemonLogPath(dataDir),
         topics: transport.getJoinedTopics(),
         connectedPeers: [...transport.getPeerSessions().values()],
+        wallet: walletStatus,
         healthy: true
     };
 }
+function collectAutoSettleCandidates(snapshot) {
+    const candidates = [];
+    for (const offer of snapshot.offers.values()) {
+        if (offer.status !== "accepted") {
+            continue;
+        }
+        for (const lightningRef of offer.lightningRefs) {
+            candidates.push({
+                triggerObjectKind: "offer",
+                triggerObjectId: offer.objectId,
+                eventId: offer.latestEventId,
+                lightningRef,
+                amountSats: offer.paymentTerms.amountSats
+            });
+        }
+    }
+    for (const bid of snapshot.bids.values()) {
+        if (bid.status !== "accepted") {
+            continue;
+        }
+        for (const lightningRef of bid.lightningRefs) {
+            candidates.push({
+                triggerObjectKind: "bid",
+                triggerObjectId: bid.objectId,
+                eventId: bid.latestEventId,
+                lightningRef,
+                amountSats: bid.paymentTerms.amountSats
+            });
+        }
+    }
+    for (const agreement of snapshot.agreements.values()) {
+        if (agreement.status !== "active") {
+            continue;
+        }
+        for (const lightningRef of agreement.lightningRefs) {
+            candidates.push({
+                triggerObjectKind: "agreement",
+                triggerObjectId: agreement.objectId,
+                eventId: agreement.latestEventId,
+                lightningRef,
+                amountSats: agreement.paymentTerms.amountSats
+            });
+        }
+    }
+    return candidates;
+}
 async function runProtocolDiscoveryWatcher(transport, seenControlLengths, io) {
     for (const session of transport.getPeerSessions().values()) {
         const remoteFeed = transport.getRemoteFeed(session.remoteControlFeedKey);
@@ -2144,56 +3037,118 @@ async function waitForProcessSignal() {
 }
 async function handleDaemonRun(args, io) {
     const dataDir = requireOption(args, "data-dir");
-    const transport = await AgentTransport.create(buildTransportConfigFromArgs(args));
     const startup = getDaemonStartupOptions(args);
+    const walletService = await WalletService.create({
+        dataDir,
+        logger: createLogger("warn")
+    });
+    walletService.setRuntimeKey(process.env.EMPORION_WALLET_KEY ?? null);
+    let transport;
     let sharedContext;
     let daemon;
     let discoveryInterval;
+    let walletPollInterval;
+    let autoSettleInterval;
+    let walletStatus = await walletService.daemonStatus();
+    let walletPollRunning = false;
+    let autoSettleRunning = false;
     const seenControlLengths = new Map();
     const startedAt = new Date().toISOString();
     try {
+        transport = await AgentTransport.create(buildTransportConfigFromArgs(args));
         await transport.start();
-        sharedContext = await buildDaemonSharedContext(dataDir, transport);
-        const topics = buildTopicsFromArgs(args, transport.identity.did);
+        const activeTransport = transport;
+        sharedContext = await buildDaemonSharedContext(dataDir, activeTransport, walletService);
+        const topics = buildTopicsFromArgs(args, activeTransport.identity.did);
         startup.topics.push(...topics);
         for (const topic of startup.topics) {
-            await transport.joinTopic(topic);
+            await activeTransport.joinTopic(topic);
         }
         for (const did of startup.connectDids) {
-            await transport.connectToDid(did);
+            await activeTransport.connectToDid(did);
         }
         for (const publicKey of startup.connectNoiseKeys) {
-            await transport.connectToNoiseKey(publicKey);
+            await activeTransport.connectToNoiseKey(publicKey);
         }
         if (startup.watchProtocol) {
             discoveryInterval = setInterval(() => {
-                void runProtocolDiscoveryWatcher(transport, seenControlLengths, io).catch((error) => {
+                void runProtocolDiscoveryWatcher(activeTransport, seenControlLengths, io).catch((error) => {
                     io.stderr(`${error instanceof Error ? error.message : String(error)}\n`);
                 });
             }, 2_000);
         }
+        walletPollInterval = setInterval(() => {
+            if (walletPollRunning) {
+                return;
+            }
+            walletPollRunning = true;
+            void (async () => {
+                try {
+                    await walletService.pollUpdates();
+                    walletStatus = await walletService.daemonStatus();
+                }
+                catch (error) {
+                    io.stderr(`${error instanceof Error ? error.message : String(error)}\n`);
+                }
+                finally {
+                    walletPollRunning = false;
+                }
+            })();
+        }, 3_000);
+        autoSettleInterval = setInterval(() => {
+            if (autoSettleRunning || !sharedContext) {
+                return;
+            }
+            autoSettleRunning = true;
+            void (async () => {
+                try {
+                    const candidates = collectAutoSettleCandidates(sharedContext.repository.getSnapshot());
+                    for (const candidate of candidates) {
+                        await walletService.attemptAutoSettle(candidate);
+                    }
+                    walletStatus = await walletService.daemonStatus();
+                }
+                catch (error) {
+                    io.stderr(`${error instanceof Error ? error.message : String(error)}\n`);
+                }
+                finally {
+                    autoSettleRunning = false;
+                }
+            })();
+        }, 2_000);
         daemon = new AgentDaemon({
             dataDir,
-            statusProvider: () => buildDaemonStatus(dataDir, startedAt, transport),
+            statusProvider: () => buildDaemonStatus(dataDir, startedAt, activeTransport, walletStatus),
             commandHandler: async (request) => {
                 if (!sharedContext) {
                     throw new Error("Daemon context is not available");
                 }
-                return CLI_CONTEXT_STORAGE.run(sharedContext, async () => executeCapturedInDaemon({
+                const result = await CLI_CONTEXT_STORAGE.run(sharedContext, async () => executeCapturedInDaemon({
                     commandPath: request.commandPath,
                     options: daemonOptionsRecordToMap(request.options)
                 }));
+                walletStatus = await walletService.daemonStatus();
+                return result;
             },
             onShutdown: async () => {
                 if (discoveryInterval) {
                     clearInterval(discoveryInterval);
                     discoveryInterval = undefined;
                 }
+                if (walletPollInterval) {
+                    clearInterval(walletPollInterval);
+                    walletPollInterval = undefined;
+                }
+                if (autoSettleInterval) {
+                    clearInterval(autoSettleInterval);
+                    autoSettleInterval = undefined;
+                }
                 if (sharedContext) {
                     await sharedContext.repository.close();
                     sharedContext = undefined;
                 }
-                await transport.stop();
+                await walletService.close();
+                await activeTransport.stop();
             }
         });
         await daemon.start();
@@ -2208,10 +3163,19 @@ async function handleDaemonRun(args, io) {
             if (discoveryInterval) {
                 clearInterval(discoveryInterval);
             }
+            if (walletPollInterval) {
+                clearInterval(walletPollInterval);
+            }
+            if (autoSettleInterval) {
+                clearInterval(autoSettleInterval);
+            }
             if (sharedContext) {
                 await sharedContext.repository.close();
             }
-            await transport.stop();
+            await walletService.close();
+            if (transport) {
+                await transport.stop();
+            }
         }
     }
 }
@@ -2220,180 +3184,229 @@ async function executeParsedArgs(args, io, options) {
         io.stdout(`${usage()}\n`);
         return 0;
     }
-    if (commandMatches(args.commandPath, "daemon", "start"))
-        return await handleDaemonStart(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "daemon", "status"))
-        return await handleDaemonStatus(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "daemon", "stop"))
-        return await handleDaemonStop(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "daemon", "logs"))
-        return await handleDaemonLogs(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "daemon", "run"))
-        return await handleDaemonRun(args, io).then(() => 0);
+    const resolvedArgs = await withResolvedDataDir(args);
+    if (commandMatches(resolvedArgs.commandPath, "daemon", "start"))
+        return await handleDaemonStart(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "daemon", "status"))
+        return await handleDaemonStatus(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "daemon", "stop"))
+        return await handleDaemonStop(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "daemon", "logs"))
+        return await handleDaemonLogs(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "daemon", "run"))
+        return await handleDaemonRun(resolvedArgs, io).then(() => 0);
     if (options.allowDaemonProxy) {
-        const dataDir = getDataDirFromArgs(args);
+        const dataDir = getDataDirFromArgs(resolvedArgs);
         if (dataDir) {
             const activeDaemon = await probeDaemonStatus(dataDir, 1_000);
             if (activeDaemon) {
-                return proxyParsedArgsToDaemon(args, io);
+                return proxyParsedArgsToDaemon(withDaemonWalletKeyForwarding(resolvedArgs), io);
             }
         }
     }
-    if (commandMatches(args.commandPath, "agent", "init"))
-        return await handleAgentInit(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "agent", "show"))
-        return await handleAgentShow(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "agent", "payment-endpoint", "add"))
-        return await handleAgentPaymentEndpointAdd(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "agent", "payment-endpoint", "remove"))
-        return await handleAgentPaymentEndpointRemove(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "agent", "wallet-attestation", "add"))
-        return await handleAgentWalletAttestationAdd(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "agent", "wallet-attestation", "remove"))
-        return await handleAgentWalletAttestationRemove(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "agent", "feedback", "add"))
-        return await handleAgentFeedbackAdd(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "agent", "feedback", "remove"))
-        return await handleAgentFeedbackRemove(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "company", "create"))
-        return await handleCompanyCreate(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "company", "show"))
-        return await handleCompanyShow(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "company", "update"))
-        return await handleCompanyUpdate(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "company", "grant-role"))
-        return await handleCompanyRoleChange(args, io, "grant").then(() => 0);
-    if (commandMatches(args.commandPath, "company", "revoke-role"))
-        return await handleCompanyRoleChange(args, io, "revoke").then(() => 0);
-    if (commandMatches(args.commandPath, "company", "join-market"))
-        return await handleCompanyMarketMembership(args, io, "join").then(() => 0);
-    if (commandMatches(args.commandPath, "company", "leave-market"))
-        return await handleCompanyMarketMembership(args, io, "leave").then(() => 0);
-    if (commandMatches(args.commandPath, "company", "treasury-attest"))
-        return await handleCompanyTreasuryAttest(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "company", "treasury-reserve"))
-        return await handleCompanyTreasuryReserve(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "company", "treasury-release"))
-        return await handleCompanyTreasuryRelease(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "market", "product", "create"))
-        return await handleMarketProductCreate(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "market", "product", "update"))
-        return await handleMarketProductUpdate(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "market", "product", "publish"))
-        return await handleMarketProductStateChange(args, io, "product.published").then(() => 0);
-    if (commandMatches(args.commandPath, "market", "product", "unpublish"))
-        return await handleMarketProductStateChange(args, io, "product.unpublished").then(() => 0);
-    if (commandMatches(args.commandPath, "market", "product", "retire"))
-        return await handleMarketProductStateChange(args, io, "product.retired").then(() => 0);
-    if (commandMatches(args.commandPath, "market", "listing", "publish"))
-        return await handleMarketListingPublish(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "market", "listing", "revise"))
-        return await handleMarketListingRevise(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "market", "listing", "withdraw"))
-        return await handleSimpleMarketStateChange(args, io, "listing", "listing.withdrawn").then(() => 0);
-    if (commandMatches(args.commandPath, "market", "listing", "expire"))
-        return await handleSimpleMarketStateChange(args, io, "listing", "listing.expired").then(() => 0);
-    if (commandMatches(args.commandPath, "market", "request", "publish"))
-        return await handleMarketRequestPublish(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "market", "request", "revise"))
-        return await handleMarketRequestRevise(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "market", "request", "close"))
-        return await handleSimpleMarketStateChange(args, io, "request", "request.closed").then(() => 0);
-    if (commandMatches(args.commandPath, "market", "request", "expire"))
-        return await handleSimpleMarketStateChange(args, io, "request", "request.expired").then(() => 0);
-    if (commandMatches(args.commandPath, "market", "offer", "submit"))
-        return await handleMarketOfferSubmit(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "market", "offer", "counter"))
-        return await handleMarketOfferCounter(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "market", "offer", "accept"))
-        return await handleSimpleMarketStateChange(args, io, "offer", "offer.accepted").then(() => 0);
-    if (commandMatches(args.commandPath, "market", "offer", "reject"))
-        return await handleSimpleMarketStateChange(args, io, "offer", "offer.rejected").then(() => 0);
-    if (commandMatches(args.commandPath, "market", "offer", "cancel"))
-        return await handleSimpleMarketStateChange(args, io, "offer", "offer.canceled").then(() => 0);
-    if (commandMatches(args.commandPath, "market", "offer", "expire"))
-        return await handleSimpleMarketStateChange(args, io, "offer", "offer.expired").then(() => 0);
-    if (commandMatches(args.commandPath, "market", "bid", "submit"))
-        return await handleMarketBidSubmit(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "market", "bid", "counter"))
-        return await handleMarketBidCounter(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "market", "bid", "accept"))
-        return await handleSimpleMarketStateChange(args, io, "bid", "bid.accepted").then(() => 0);
-    if (commandMatches(args.commandPath, "market", "bid", "reject"))
-        return await handleSimpleMarketStateChange(args, io, "bid", "bid.rejected").then(() => 0);
-    if (commandMatches(args.commandPath, "market", "bid", "cancel"))
-        return await handleSimpleMarketStateChange(args, io, "bid", "bid.canceled").then(() => 0);
-    if (commandMatches(args.commandPath, "market", "bid", "expire"))
-        return await handleSimpleMarketStateChange(args, io, "bid", "bid.expired").then(() => 0);
-    if (commandMatches(args.commandPath, "market", "agreement", "create"))
-        return await handleMarketAgreementCreate(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "market", "agreement", "complete"))
-        return await handleSimpleMarketStateChange(args, io, "agreement", "agreement.completed").then(() => 0);
-    if (commandMatches(args.commandPath, "market", "agreement", "cancel"))
-        return await handleSimpleMarketStateChange(args, io, "agreement", "agreement.canceled").then(() => 0);
-    if (commandMatches(args.commandPath, "market", "agreement", "dispute"))
-        return await handleSimpleMarketStateChange(args, io, "agreement", "agreement.disputed").then(() => 0);
-    if (commandMatches(args.commandPath, "market", "list"))
-        return await handleMarketList(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "contract", "create"))
-        return await handleContractCreate(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "contract", "open-milestone"))
-        return await handleContractMilestoneAction(args, io, "contract.milestone-opened").then(() => 0);
-    if (commandMatches(args.commandPath, "contract", "submit-milestone"))
-        return await handleContractMilestoneAction(args, io, "contract.milestone-submitted").then(() => 0);
-    if (commandMatches(args.commandPath, "contract", "accept-milestone"))
-        return await handleContractMilestoneAction(args, io, "contract.milestone-accepted").then(() => 0);
-    if (commandMatches(args.commandPath, "contract", "reject-milestone"))
-        return await handleContractMilestoneAction(args, io, "contract.milestone-rejected").then(() => 0);
-    if (commandMatches(args.commandPath, "contract", "pause"))
-        return await handleContractStateChange(args, io, "contract.paused").then(() => 0);
-    if (commandMatches(args.commandPath, "contract", "resume"))
-        return await handleContractStateChange(args, io, "contract.resumed").then(() => 0);
-    if (commandMatches(args.commandPath, "contract", "complete"))
-        return await handleContractStateChange(args, io, "contract.completed").then(() => 0);
-    if (commandMatches(args.commandPath, "contract", "cancel"))
-        return await handleContractStateChange(args, io, "contract.canceled").then(() => 0);
-    if (commandMatches(args.commandPath, "contract", "dispute"))
-        return await handleContractStateChange(args, io, "contract.disputed").then(() => 0);
-    if (commandMatches(args.commandPath, "contract", "entries"))
-        return await handleContractEntries(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "evidence", "record"))
-        return await handleEvidenceRecord(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "oracle", "attest"))
-        return await handleOracleAttest(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "dispute", "open"))
-        return await handleDisputeOpen(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "dispute", "add-evidence"))
-        return await handleDisputeAddEvidence(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "dispute", "request-oracle"))
-        return await handleDisputeRequestOracle(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "dispute", "rule"))
-        return await handleDisputeRule(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "dispute", "close"))
-        return await handleDisputeClose(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "space", "create"))
-        return await handleSpaceCreate(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "space", "add-member"))
-        return await handleSpaceMembershipAction(args, io, "space-membership.member-added").then(() => 0);
-    if (commandMatches(args.commandPath, "space", "remove-member"))
-        return await handleSpaceMembershipAction(args, io, "space-membership.member-removed").then(() => 0);
-    if (commandMatches(args.commandPath, "space", "mute-member"))
-        return await handleSpaceMembershipAction(args, io, "space-membership.member-muted").then(() => 0);
-    if (commandMatches(args.commandPath, "space", "set-role"))
-        return await handleSpaceMembershipAction(args, io, "space-membership.member-role-updated").then(() => 0);
-    if (commandMatches(args.commandPath, "space", "entries"))
-        return await handleSpaceEntries(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "message", "send"))
-        return await handleMessageSend(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "message", "edit"))
-        return await handleMessageEdit(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "message", "delete"))
-        return await handleMessageDelete(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "message", "react"))
-        return await handleMessageReact(args, io).then(() => 0);
-    if (commandMatches(args.commandPath, "object", "show"))
-        return await handleObjectShow(args, io).then(() => 0);
-    throw new Error(`Unknown command: ${args.commandPath.join(" ")}`);
+    if (commandMatches(resolvedArgs.commandPath, "context", "add"))
+        return await handleContextAdd(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "context", "use"))
+        return await handleContextUse(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "context", "list"))
+        return await handleContextList(io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "context", "show"))
+        return await handleContextShow(io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "context", "remove"))
+        return await handleContextRemove(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "agent", "init"))
+        return await handleAgentInit(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "wallet", "connect", "nwc"))
+        return await handleWalletConnectNwc(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "wallet", "disconnect"))
+        return await handleWalletDisconnect(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "wallet", "status"))
+        return await handleWalletStatus(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "wallet", "unlock"))
+        return await handleWalletUnlock(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "wallet", "lock"))
+        return await handleWalletLock(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "wallet", "invoice", "create"))
+        return await handleWalletInvoiceCreate(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "wallet", "pay", "bolt11"))
+        return await handleWalletPayBolt11(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "wallet", "ledger", "list"))
+        return await handleWalletLedgerList(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "wallet", "key", "rotate"))
+        return await handleWalletKeyRotate(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "deal", "open"))
+        return await handleDealOpen(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "deal", "propose"))
+        return await handleDealPropose(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "deal", "accept"))
+        return await handleDealAccept(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "deal", "start"))
+        return await handleDealStart(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "deal", "status"))
+        return await handleDealStatus(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "proof", "submit"))
+        return await handleProofSubmit(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "proof", "accept"))
+        return await handleProofAccept(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "settlement", "invoice", "create"))
+        return await handleSettlementInvoiceCreate(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "settlement", "pay"))
+        return await handleSettlementPay(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "settlement", "status"))
+        return await handleSettlementStatus(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "agent", "show"))
+        return await handleAgentShow(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "agent", "payment-endpoint", "add"))
+        return await handleAgentPaymentEndpointAdd(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "agent", "payment-endpoint", "remove"))
+        return await handleAgentPaymentEndpointRemove(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "agent", "wallet-attestation", "add"))
+        return await handleAgentWalletAttestationAdd(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "agent", "wallet-attestation", "remove"))
+        return await handleAgentWalletAttestationRemove(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "agent", "feedback", "add"))
+        return await handleAgentFeedbackAdd(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "agent", "feedback", "remove"))
+        return await handleAgentFeedbackRemove(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "company", "create"))
+        return await handleCompanyCreate(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "company", "show"))
+        return await handleCompanyShow(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "company", "update"))
+        return await handleCompanyUpdate(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "company", "grant-role"))
+        return await handleCompanyRoleChange(resolvedArgs, io, "grant").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "company", "revoke-role"))
+        return await handleCompanyRoleChange(resolvedArgs, io, "revoke").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "company", "join-market"))
+        return await handleCompanyMarketMembership(resolvedArgs, io, "join").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "company", "leave-market"))
+        return await handleCompanyMarketMembership(resolvedArgs, io, "leave").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "company", "treasury-attest"))
+        return await handleCompanyTreasuryAttest(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "company", "treasury-reserve"))
+        return await handleCompanyTreasuryReserve(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "company", "treasury-release"))
+        return await handleCompanyTreasuryRelease(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "market", "product", "create"))
+        return await handleMarketProductCreate(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "market", "product", "update"))
+        return await handleMarketProductUpdate(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "market", "product", "publish"))
+        return await handleMarketProductStateChange(resolvedArgs, io, "product.published").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "market", "product", "unpublish"))
+        return await handleMarketProductStateChange(resolvedArgs, io, "product.unpublished").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "market", "product", "retire"))
+        return await handleMarketProductStateChange(resolvedArgs, io, "product.retired").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "market", "listing", "publish"))
+        return await handleMarketListingPublish(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "market", "listing", "revise"))
+        return await handleMarketListingRevise(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "market", "listing", "withdraw"))
+        return await handleSimpleMarketStateChange(resolvedArgs, io, "listing", "listing.withdrawn").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "market", "listing", "expire"))
+        return await handleSimpleMarketStateChange(resolvedArgs, io, "listing", "listing.expired").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "market", "request", "publish"))
+        return await handleMarketRequestPublish(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "market", "request", "revise"))
+        return await handleMarketRequestRevise(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "market", "request", "close"))
+        return await handleSimpleMarketStateChange(resolvedArgs, io, "request", "request.closed").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "market", "request", "expire"))
+        return await handleSimpleMarketStateChange(resolvedArgs, io, "request", "request.expired").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "market", "offer", "submit"))
+        return await handleMarketOfferSubmit(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "market", "offer", "counter"))
+        return await handleMarketOfferCounter(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "market", "offer", "accept"))
+        return await handleSimpleMarketStateChange(resolvedArgs, io, "offer", "offer.accepted").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "market", "offer", "reject"))
+        return await handleSimpleMarketStateChange(resolvedArgs, io, "offer", "offer.rejected").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "market", "offer", "cancel"))
+        return await handleSimpleMarketStateChange(resolvedArgs, io, "offer", "offer.canceled").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "market", "offer", "expire"))
+        return await handleSimpleMarketStateChange(resolvedArgs, io, "offer", "offer.expired").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "market", "bid", "submit"))
+        return await handleMarketBidSubmit(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "market", "bid", "counter"))
+        return await handleMarketBidCounter(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "market", "bid", "accept"))
+        return await handleSimpleMarketStateChange(resolvedArgs, io, "bid", "bid.accepted").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "market", "bid", "reject"))
+        return await handleSimpleMarketStateChange(resolvedArgs, io, "bid", "bid.rejected").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "market", "bid", "cancel"))
+        return await handleSimpleMarketStateChange(resolvedArgs, io, "bid", "bid.canceled").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "market", "bid", "expire"))
+        return await handleSimpleMarketStateChange(resolvedArgs, io, "bid", "bid.expired").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "market", "agreement", "create"))
+        return await handleMarketAgreementCreate(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "market", "agreement", "complete"))
+        return await handleSimpleMarketStateChange(resolvedArgs, io, "agreement", "agreement.completed").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "market", "agreement", "cancel"))
+        return await handleSimpleMarketStateChange(resolvedArgs, io, "agreement", "agreement.canceled").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "market", "agreement", "dispute"))
+        return await handleSimpleMarketStateChange(resolvedArgs, io, "agreement", "agreement.disputed").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "market", "list"))
+        return await handleMarketList(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "contract", "create"))
+        return await handleContractCreate(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "contract", "open-milestone"))
+        return await handleContractMilestoneAction(resolvedArgs, io, "contract.milestone-opened").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "contract", "submit-milestone"))
+        return await handleContractMilestoneAction(resolvedArgs, io, "contract.milestone-submitted").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "contract", "accept-milestone"))
+        return await handleContractMilestoneAction(resolvedArgs, io, "contract.milestone-accepted").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "contract", "reject-milestone"))
+        return await handleContractMilestoneAction(resolvedArgs, io, "contract.milestone-rejected").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "contract", "pause"))
+        return await handleContractStateChange(resolvedArgs, io, "contract.paused").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "contract", "resume"))
+        return await handleContractStateChange(resolvedArgs, io, "contract.resumed").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "contract", "complete"))
+        return await handleContractStateChange(resolvedArgs, io, "contract.completed").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "contract", "cancel"))
+        return await handleContractStateChange(resolvedArgs, io, "contract.canceled").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "contract", "dispute"))
+        return await handleContractStateChange(resolvedArgs, io, "contract.disputed").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "contract", "entries"))
+        return await handleContractEntries(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "evidence", "record"))
+        return await handleEvidenceRecord(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "oracle", "attest"))
+        return await handleOracleAttest(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "dispute", "open"))
+        return await handleDisputeOpen(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "dispute", "add-evidence"))
+        return await handleDisputeAddEvidence(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "dispute", "request-oracle"))
+        return await handleDisputeRequestOracle(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "dispute", "rule"))
+        return await handleDisputeRule(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "dispute", "close"))
+        return await handleDisputeClose(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "space", "create"))
+        return await handleSpaceCreate(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "space", "add-member"))
+        return await handleSpaceMembershipAction(resolvedArgs, io, "space-membership.member-added").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "space", "remove-member"))
+        return await handleSpaceMembershipAction(resolvedArgs, io, "space-membership.member-removed").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "space", "mute-member"))
+        return await handleSpaceMembershipAction(resolvedArgs, io, "space-membership.member-muted").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "space", "set-role"))
+        return await handleSpaceMembershipAction(resolvedArgs, io, "space-membership.member-role-updated").then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "space", "entries"))
+        return await handleSpaceEntries(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "message", "send"))
+        return await handleMessageSend(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "message", "edit"))
+        return await handleMessageEdit(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "message", "delete"))
+        return await handleMessageDelete(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "message", "react"))
+        return await handleMessageReact(resolvedArgs, io).then(() => 0);
+    if (commandMatches(resolvedArgs.commandPath, "object", "show"))
+        return await handleObjectShow(resolvedArgs, io).then(() => 0);
+    throw new Error(`Unknown command: ${resolvedArgs.commandPath.join(" ")}`);
 }
 export async function runCli(argv, io = DEFAULT_IO) {
     try {