@garydevenay/emporion 0.0.1

package/dist/src/cli.js

@@ -0,0 +1,2101 @@
+#!/usr/bin/env node
+import { once } from "node:events";
+import { AgentTransport } from "./transport.js";
+import { createLogger } from "./logger.js";
+import { loadPersistentIdentityMaterial } from "./persistent-agent.js";
+import * as Protocol from "./protocol/index.js";
+import { sha256Hex } from "./protocol/shared.js";
+import { TransportStorage } from "./storage.js";
+const DEFAULT_IO = {
+    stdout(message) {
+        process.stdout.write(message);
+    },
+    stderr(message) {
+        process.stderr.write(message);
+    }
+};
+function parseArgs(argv) {
+    const commandPath = [];
+    const options = new Map();
+    let index = 0;
+    while (index < argv.length && !argv[index]?.startsWith("--")) {
+        commandPath.push(argv[index]);
+        index += 1;
+    }
+    while (index < argv.length) {
+        const token = argv[index];
+        if (!token?.startsWith("--")) {
+            throw new Error(`Unexpected positional argument: ${token ?? ""}`);
+        }
+        const optionName = token.slice(2);
+        if (optionName.length === 0) {
+            throw new Error("Option names must not be blank");
+        }
+        const nextToken = argv[index + 1];
+        const value = !nextToken || nextToken.startsWith("--") ? "true" : nextToken;
+        const existing = options.get(optionName) ?? [];
+        existing.push(value);
+        options.set(optionName, existing);
+        index += value === "true" ? 1 : 2;
+    }
+    return { commandPath, options };
+}
+function commandMatches(commandPath, ...expected) {
+    return commandPath.length === expected.length && expected.every((value, index) => commandPath[index] === value);
+}
+function getOptionValues(args, name) {
+    return args.options.get(name) ?? [];
+}
+function hasFlag(args, name) {
+    return getOptionValues(args, name).includes("true");
+}
+function getOptionalOption(args, name) {
+    const values = getOptionValues(args, name).filter((value) => value !== "true");
+    return values.at(-1);
+}
+function requireOption(args, name) {
+    const value = getOptionalOption(args, name);
+    if (!value || value.trim().length === 0) {
+        throw new Error(`Missing required option --${name}`);
+    }
+    return value;
+}
+function getCsvOptionValues(args, name) {
+    return getOptionValues(args, name)
+        .flatMap((value) => value.split(","))
+        .map((value) => value.trim())
+        .filter((value) => value.length > 0 && value !== "true");
+}
+function parsePositiveInteger(value, fieldName) {
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw new Error(`${fieldName} must be a positive integer`);
+    }
+    return parsed;
+}
+function parseNonNegativeInteger(value, fieldName) {
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isInteger(parsed) || parsed < 0) {
+        throw new Error(`${fieldName} must be a non-negative integer`);
+    }
+    return parsed;
+}
+function parseOptionalNonNegativeInteger(args, name) {
+    const value = getOptionalOption(args, name);
+    return value === undefined ? undefined : parseNonNegativeInteger(value, `--${name}`);
+}
+function parseEnum(value, fieldName, allowed) {
+    if (allowed.includes(value)) {
+        return value;
+    }
+    throw new Error(`${fieldName} must be one of: ${allowed.join(", ")}`);
+}
+function now() {
+    return new Date().toISOString();
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isStateWithLatestEventId(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        typeof value.latestEventId === "string" &&
+        Array.isArray(value.eventIds));
+}
+function defaultObjectId(kind, seed) {
+    return `emporion:${kind}:${sha256Hex(seed)}`;
+}
+function toProtocolJsonObject(value) {
+    return value;
+}
+function toProtocolValue(value) {
+    return value;
+}
+function parsePaymentTerms(args, options) {
+    const amountOption = options?.amountOption ?? "amount-sats";
+    const currencyOption = options?.currencyOption ?? "currency";
+    const settlementOption = options?.settlementOption ?? "settlement";
+    return {
+        amountSats: parsePositiveInteger(requireOption(args, amountOption), `--${amountOption}`),
+        currency: parseEnum(getOptionalOption(args, currencyOption) ?? "SAT", `--${currencyOption}`, ["BTC", "SAT"]),
+        settlementMethod: parseEnum(getOptionalOption(args, settlementOption) ?? "lightning", `--${settlementOption}`, ["lightning", "custodial"])
+    };
+}
+function mergePaymentTerms(args, current, options) {
+    const amountOption = options?.amountOption ?? "amount-sats";
+    const currencyOption = options?.currencyOption ?? "currency";
+    const settlementOption = options?.settlementOption ?? "settlement";
+    const amountValue = getOptionalOption(args, amountOption);
+    const currencyValue = getOptionalOption(args, currencyOption);
+    const settlementValue = getOptionalOption(args, settlementOption);
+    return {
+        amountSats: amountValue ? parsePositiveInteger(amountValue, `--${amountOption}`) : current.amountSats,
+        currency: currencyValue
+            ? parseEnum(currencyValue, `--${currencyOption}`, ["BTC", "SAT"])
+            : current.currency,
+        settlementMethod: settlementValue
+            ? parseEnum(settlementValue, `--${settlementOption}`, ["lightning", "custodial"])
+            : current.settlementMethod
+    };
+}
+function parseLightningRefs(args) {
+    return getOptionValues(args, "lightning-ref")
+        .filter((value) => value !== "true")
+        .map((value) => {
+        const match = /^([^:]+):([^:]+):(.+)$/.exec(value);
+        if (!match) {
+            throw new Error("--lightning-ref must use <type>:<network>:<reference>");
+        }
+        const [, type, network, reference] = match;
+        if (!type || !network || !reference) {
+            throw new Error("--lightning-ref must use <type>:<network>:<reference>");
+        }
+        return {
+            type: parseEnum(type, "--lightning-ref type", [
+                "bolt11",
+                "bolt12-offer",
+                "bolt12-invoice-request",
+                "custodial-payment-ref"
+            ]),
+            network: parseEnum(network, "--lightning-ref network", [
+                "bitcoin",
+                "testnet",
+                "signet",
+                "regtest"
+            ]),
+            reference
+        };
+    });
+}
+function parseJsonOption(args, name) {
+    const value = requireOption(args, name);
+    try {
+        return JSON.parse(value);
+    }
+    catch (error) {
+        throw new Error(`--${name} must be valid JSON: ${error.message}`);
+    }
+}
+function getUniqueOptionValues(args, name) {
+    return [...new Set(getOptionValues(args, name).filter((value) => value !== "true"))].sort();
+}
+function writeJson(io, value) {
+    io.stdout(`${JSON.stringify(value, null, 2)}\n`);
+}
+async function withCliContext(dataDir, fn) {
+    const identityMaterial = await loadPersistentIdentityMaterial(dataDir);
+    const repository = await Protocol.ProtocolRepository.create(dataDir);
+    const transportStorage = await TransportStorage.create(dataDir, identityMaterial.storagePrimaryKey, createLogger("error"));
+    await transportStorage.initializeDefaults();
+    try {
+        return await fn({
+            dataDir,
+            identityMaterial,
+            repository,
+            transportStorage,
+            signer: {
+                did: identityMaterial.agentIdentity.did,
+                publicKey: identityMaterial.transportKeyPair.publicKey,
+                secretKey: identityMaterial.transportKeyPair.secretKey
+            }
+        });
+    }
+    finally {
+        await transportStorage.close();
+        await repository.close();
+    }
+}
+async function readRequiredState(repository, objectKind, objectId) {
+    const state = await repository.readObjectState(objectKind, objectId);
+    if (!state) {
+        throw new Error(`No ${objectKind} state found for ${objectId}`);
+    }
+    return state;
+}
+async function ensureAgentProfileExists(context) {
+    const profile = await context.repository.readObjectState("agent-profile", context.identityMaterial.agentIdentity.did);
+    if (profile) {
+        return profile;
+    }
+    const result = await appendEnvelope(context, {
+        objectKind: "agent-profile",
+        objectId: context.identityMaterial.agentIdentity.did,
+        eventKind: "agent-profile.created",
+        subjectId: context.identityMaterial.agentIdentity.did,
+        payload: {}
+    });
+    return result.state;
+}
+function listActiveSpaceMemberDids(context, spaceId) {
+    const members = [];
+    for (const membership of context.repository.getSnapshot().spaceMemberships.values()) {
+        if (membership.spaceId === spaceId && membership.status !== "removed") {
+            members.push(membership.memberDid);
+        }
+    }
+    return [...new Set(members)].sort();
+}
+async function appendEnvelope(context, input) {
+    const currentState = await context.repository.readObjectState(input.objectKind, input.objectId);
+    const previousEventIds = isStateWithLatestEventId(currentState) ? [currentState.latestEventId] : [];
+    const unsignedEnvelope = Protocol.createUnsignedEnvelope({
+        objectKind: input.objectKind,
+        objectId: input.objectId,
+        eventKind: input.eventKind,
+        actorDid: context.identityMaterial.agentIdentity.did,
+        subjectId: input.subjectId,
+        issuedAt: input.issuedAt ?? now(),
+        previousEventIds,
+        payload: input.payload,
+        ...(input.attachments ? { attachments: input.attachments } : {})
+    });
+    const envelope = Protocol.signProtocolEnvelope(unsignedEnvelope, context.signer);
+    await context.repository.appendEnvelope(envelope);
+    const nextState = await context.repository.readObjectState(input.objectKind, input.objectId);
+    if (nextState) {
+        const controlFeed = await context.transportStorage.openFeed("control");
+        const announcement = Protocol.createProtocolAnnouncement(envelope, nextState);
+        await controlFeed.append(Protocol.protocolAnnouncementToJson(announcement));
+    }
+    return {
+        envelope,
+        state: nextState
+    };
+}
+async function handleAgentInit(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    await withCliContext(dataDir, async (context) => {
+        const displayName = getOptionalOption(args, "display-name");
+        const bio = getOptionalOption(args, "bio");
+        const currentProfile = await context.repository.readObjectState("agent-profile", context.identityMaterial.agentIdentity.did);
+        let mutation;
+        if (!currentProfile) {
+            mutation = await appendEnvelope(context, {
+                objectKind: "agent-profile",
+                objectId: context.identityMaterial.agentIdentity.did,
+                eventKind: "agent-profile.created",
+                subjectId: context.identityMaterial.agentIdentity.did,
+                payload: {
+                    ...(displayName ? { displayName } : {}),
+                    ...(bio ? { bio } : {})
+                }
+            });
+        }
+        else if (displayName !== undefined || bio !== undefined) {
+            const profile = currentProfile;
+            if (displayName !== profile.displayName || bio !== profile.bio) {
+                mutation = await appendEnvelope(context, {
+                    objectKind: "agent-profile",
+                    objectId: context.identityMaterial.agentIdentity.did,
+                    eventKind: "agent-profile.updated",
+                    subjectId: context.identityMaterial.agentIdentity.did,
+                    payload: {
+                        ...(displayName !== undefined ? { displayName } : {}),
+                        ...(bio !== undefined ? { bio } : {})
+                    }
+                });
+            }
+        }
+        writeJson(io, {
+            command: "agent.init",
+            identity: context.identityMaterial.agentIdentity,
+            profile: mutation?.state ??
+                (await context.repository.readObjectState("agent-profile", context.identityMaterial.agentIdentity.did)),
+            eventId: mutation?.envelope.eventId
+        });
+    });
+}
+async function handleAgentShow(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    await withCliContext(dataDir, async (context) => {
+        writeJson(io, {
+            command: "agent.show",
+            identity: context.identityMaterial.agentIdentity,
+            profile: await context.repository.readObjectState("agent-profile", context.identityMaterial.agentIdentity.did)
+        });
+    });
+}
+async function handleAgentPaymentEndpointAdd(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    await withCliContext(dataDir, async (context) => {
+        await ensureAgentProfileExists(context);
+        const capabilities = getCsvOptionValues(args, "capability");
+        if (capabilities.length === 0) {
+            throw new Error("At least one --capability is required");
+        }
+        const accountId = getOptionalOption(args, "account-id");
+        const nodeUri = getOptionalOption(args, "node-uri");
+        const bolt12Offer = getOptionalOption(args, "bolt12-offer");
+        const endpoint = {
+            id: requireOption(args, "id"),
+            network: parseEnum(getOptionalOption(args, "network") ?? "bitcoin", "--network", [
+                "bitcoin",
+                "testnet",
+                "signet",
+                "regtest"
+            ]),
+            custodial: hasFlag(args, "custodial"),
+            capabilities,
+            ...(accountId ? { accountId } : {}),
+            ...(nodeUri ? { nodeUri } : {}),
+            ...(bolt12Offer ? { bolt12Offer } : {})
+        };
+        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)
+        });
+        writeJson(io, {
+            command: "agent.payment-endpoint.add",
+            eventId: result.envelope.eventId,
+            profile: result.state
+        });
+    });
+}
+async function handleAgentPaymentEndpointRemove(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const paymentEndpointId = requireOption(args, "payment-endpoint-id");
+    await withCliContext(dataDir, async (context) => {
+        await ensureAgentProfileExists(context);
+        const result = await appendEnvelope(context, {
+            objectKind: "agent-profile",
+            objectId: context.identityMaterial.agentIdentity.did,
+            eventKind: "agent-profile.payment-endpoint-removed",
+            subjectId: context.identityMaterial.agentIdentity.did,
+            payload: {
+                paymentEndpointId
+            }
+        });
+        writeJson(io, {
+            command: "agent.payment-endpoint.remove",
+            eventId: result.envelope.eventId,
+            profile: result.state
+        });
+    });
+}
+async function handleAgentWalletAttestationAdd(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    await withCliContext(dataDir, async (context) => {
+        await ensureAgentProfileExists(context);
+        const attestedAt = getOptionalOption(args, "attested-at") ?? now();
+        const artifact = getOptionalOption(args, "artifact") ?? "";
+        const attestedCapacitySats = parseOptionalNonNegativeInteger(args, "capacity-sats");
+        const artifactUri = getOptionalOption(args, "artifact-uri");
+        const attestation = {
+            attestationId: requireOption(args, "attestation-id"),
+            issuerDid: getOptionalOption(args, "issuer-did") ?? context.identityMaterial.agentIdentity.did,
+            subjectDid: context.identityMaterial.agentIdentity.did,
+            walletAccountId: requireOption(args, "wallet-account-id"),
+            network: parseEnum(getOptionalOption(args, "network") ?? "bitcoin", "--network", [
+                "bitcoin",
+                "testnet",
+                "signet",
+                "regtest"
+            ]),
+            currency: parseEnum(getOptionalOption(args, "currency") ?? "SAT", "--currency", ["BTC", "SAT"]),
+            attestedBalanceSats: parseNonNegativeInteger(requireOption(args, "balance-sats"), "--balance-sats"),
+            ...(attestedCapacitySats !== undefined ? { attestedCapacitySats } : {}),
+            attestedAt,
+            expiresAt: requireOption(args, "expires-at"),
+            artifactHash: Protocol.createCredentialArtifactHash(artifact),
+            ...(artifactUri ? { artifactUri } : {})
+        };
+        const result = await appendEnvelope(context, {
+            objectKind: "agent-profile",
+            objectId: context.identityMaterial.agentIdentity.did,
+            eventKind: "agent-profile.wallet-attestation-added",
+            subjectId: context.identityMaterial.agentIdentity.did,
+            payload: Protocol.custodialWalletAttestationToJson(attestation)
+        });
+        writeJson(io, {
+            command: "agent.wallet-attestation.add",
+            eventId: result.envelope.eventId,
+            profile: result.state
+        });
+    });
+}
+async function handleAgentWalletAttestationRemove(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const attestationId = requireOption(args, "attestation-id");
+    await withCliContext(dataDir, async (context) => {
+        await ensureAgentProfileExists(context);
+        const result = await appendEnvelope(context, {
+            objectKind: "agent-profile",
+            objectId: context.identityMaterial.agentIdentity.did,
+            eventKind: "agent-profile.wallet-attestation-removed",
+            subjectId: context.identityMaterial.agentIdentity.did,
+            payload: {
+                attestationId
+            }
+        });
+        writeJson(io, {
+            command: "agent.wallet-attestation.remove",
+            eventId: result.envelope.eventId,
+            profile: result.state
+        });
+    });
+}
+async function handleAgentFeedbackAdd(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    await withCliContext(dataDir, async (context) => {
+        await ensureAgentProfileExists(context);
+        const issuedAt = getOptionalOption(args, "issued-at") ?? now();
+        const artifact = getOptionalOption(args, "artifact") ?? "";
+        const headline = getOptionalOption(args, "headline");
+        const comment = getOptionalOption(args, "comment");
+        const expiresAt = getOptionalOption(args, "expires-at");
+        const artifactUri = getOptionalOption(args, "artifact-uri");
+        const revocationRef = getOptionalOption(args, "revocation-ref");
+        const completionArtifactRef = getOptionalOption(args, "completion-artifact-ref");
+        const rulingRef = getOptionalOption(args, "ruling-ref");
+        const credential = {
+            credentialId: requireOption(args, "credential-id"),
+            issuerDid: requireOption(args, "issuer-did"),
+            subjectDid: context.identityMaterial.agentIdentity.did,
+            relatedContractId: requireOption(args, "contract-id"),
+            relatedAgreementId: requireOption(args, "agreement-id"),
+            ...(completionArtifactRef ? { completionArtifactRef } : {}),
+            ...(rulingRef ? { rulingRef } : {}),
+            summary: {
+                score: parseNonNegativeInteger(requireOption(args, "score"), "--score"),
+                maxScore: parsePositiveInteger(requireOption(args, "max-score"), "--max-score"),
+                ...(headline ? { headline } : {}),
+                ...(comment ? { comment } : {})
+            },
+            issuedAt,
+            ...(expiresAt ? { expiresAt } : {}),
+            artifactHash: Protocol.createCredentialArtifactHash(artifact),
+            ...(artifactUri ? { artifactUri } : {}),
+            ...(revocationRef ? { revocationRef } : {})
+        };
+        const recorded = await appendEnvelope(context, {
+            objectKind: "feedback-credential-ref",
+            objectId: credential.credentialId,
+            eventKind: "feedback-credential-ref.recorded",
+            subjectId: credential.credentialId,
+            payload: Protocol.feedbackCredentialRefToJson(credential),
+            issuedAt
+        });
+        const added = await appendEnvelope(context, {
+            objectKind: "agent-profile",
+            objectId: context.identityMaterial.agentIdentity.did,
+            eventKind: "agent-profile.feedback-credential-added",
+            subjectId: context.identityMaterial.agentIdentity.did,
+            payload: Protocol.feedbackCredentialRefToJson(credential)
+        });
+        writeJson(io, {
+            command: "agent.feedback.add",
+            feedbackEventId: recorded.envelope.eventId,
+            profileEventId: added.envelope.eventId,
+            profile: added.state,
+            feedback: await context.repository.readObjectState("feedback-credential-ref", credential.credentialId)
+        });
+    });
+}
+async function handleAgentFeedbackRemove(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const credentialId = requireOption(args, "credential-id");
+    await withCliContext(dataDir, async (context) => {
+        await ensureAgentProfileExists(context);
+        const feedbackState = await context.repository.readObjectState("feedback-credential-ref", credentialId);
+        if (feedbackState) {
+            await appendEnvelope(context, {
+                objectKind: "feedback-credential-ref",
+                objectId: credentialId,
+                eventKind: "feedback-credential-ref.revoked",
+                subjectId: credentialId,
+                payload: {}
+            });
+        }
+        const removed = await appendEnvelope(context, {
+            objectKind: "agent-profile",
+            objectId: context.identityMaterial.agentIdentity.did,
+            eventKind: "agent-profile.feedback-credential-removed",
+            subjectId: context.identityMaterial.agentIdentity.did,
+            payload: {
+                credentialId
+            }
+        });
+        writeJson(io, {
+            command: "agent.feedback.remove",
+            profileEventId: removed.envelope.eventId,
+            profile: removed.state,
+            feedback: await context.repository.readObjectState("feedback-credential-ref", credentialId)
+        });
+    });
+}
+async function handleCompanyCreate(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    await withCliContext(dataDir, async (context) => {
+        const issuedAt = now();
+        const description = getOptionalOption(args, "description");
+        const payload = {
+            name: requireOption(args, "name"),
+            initialOwners: [context.identityMaterial.agentIdentity.did],
+            ...(description ? { description } : {})
+        };
+        const companyDid = Protocol.deriveCompanyDidFromGenesis({
+            actorDid: context.identityMaterial.agentIdentity.did,
+            issuedAt,
+            payload
+        });
+        const result = await appendEnvelope(context, {
+            objectKind: "company",
+            objectId: companyDid,
+            eventKind: "company.genesis",
+            subjectId: companyDid,
+            payload: payload,
+            issuedAt
+        });
+        writeJson(io, {
+            command: "company.create",
+            companyDid,
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleCompanyShow(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const companyDid = requireOption(args, "company-did");
+    await withCliContext(dataDir, async (context) => {
+        writeJson(io, {
+            command: "company.show",
+            state: await context.repository.readObjectState("company", companyDid)
+        });
+    });
+}
+async function handleCompanyUpdate(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const companyDid = requireOption(args, "company-did");
+    const name = getOptionalOption(args, "name");
+    const description = getOptionalOption(args, "description");
+    if (name === undefined && description === undefined) {
+        throw new Error("At least one of --name or --description is required");
+    }
+    await withCliContext(dataDir, async (context) => {
+        const result = await appendEnvelope(context, {
+            objectKind: "company",
+            objectId: companyDid,
+            eventKind: "company.profile-updated",
+            subjectId: companyDid,
+            payload: {
+                ...(name !== undefined ? { name } : {}),
+                ...(description !== undefined ? { description } : {})
+            }
+        });
+        writeJson(io, {
+            command: "company.update",
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleCompanyRoleChange(args, io, mode) {
+    const dataDir = requireOption(args, "data-dir");
+    const companyDid = requireOption(args, "company-did");
+    await withCliContext(dataDir, async (context) => {
+        const result = await appendEnvelope(context, {
+            objectKind: "company",
+            objectId: companyDid,
+            eventKind: mode === "grant" ? "company.role-granted" : "company.role-revoked",
+            subjectId: companyDid,
+            payload: {
+                memberDid: requireOption(args, "member-did"),
+                role: parseEnum(requireOption(args, "role"), "--role", ["owner", "operator", "member"])
+            }
+        });
+        writeJson(io, {
+            command: mode === "grant" ? "company.grant-role" : "company.revoke-role",
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleCompanyMarketMembership(args, io, mode) {
+    const dataDir = requireOption(args, "data-dir");
+    const companyDid = requireOption(args, "company-did");
+    const marketplaceId = requireOption(args, "marketplace");
+    await withCliContext(dataDir, async (context) => {
+        const result = await appendEnvelope(context, {
+            objectKind: "company",
+            objectId: companyDid,
+            eventKind: mode === "join" ? "company.market-joined" : "company.market-left",
+            subjectId: companyDid,
+            payload: {
+                marketplaceId
+            }
+        });
+        writeJson(io, {
+            command: mode === "join" ? "company.join-market" : "company.leave-market",
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleCompanyTreasuryAttest(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const companyDid = requireOption(args, "company-did");
+    const attestedAt = getOptionalOption(args, "attested-at") ?? now();
+    const artifact = getOptionalOption(args, "artifact") ?? "";
+    await withCliContext(dataDir, async (context) => {
+        const attestedCapacitySats = parseOptionalNonNegativeInteger(args, "capacity-sats");
+        const artifactUri = getOptionalOption(args, "artifact-uri");
+        const attestation = {
+            attestationId: requireOption(args, "attestation-id"),
+            issuerDid: getOptionalOption(args, "issuer-did") ?? context.identityMaterial.agentIdentity.did,
+            subjectDid: companyDid,
+            walletAccountId: requireOption(args, "wallet-account-id"),
+            network: parseEnum(getOptionalOption(args, "network") ?? "bitcoin", "--network", [
+                "bitcoin",
+                "testnet",
+                "signet",
+                "regtest"
+            ]),
+            currency: parseEnum(getOptionalOption(args, "currency") ?? "SAT", "--currency", ["BTC", "SAT"]),
+            attestedBalanceSats: parseNonNegativeInteger(requireOption(args, "balance-sats"), "--balance-sats"),
+            ...(attestedCapacitySats !== undefined ? { attestedCapacitySats } : {}),
+            attestedAt,
+            expiresAt: requireOption(args, "expires-at"),
+            artifactHash: Protocol.createCredentialArtifactHash(artifact),
+            ...(artifactUri ? { artifactUri } : {})
+        };
+        const result = await appendEnvelope(context, {
+            objectKind: "company",
+            objectId: companyDid,
+            eventKind: "company.treasury-attested",
+            subjectId: companyDid,
+            payload: Protocol.custodialWalletAttestationToJson(attestation)
+        });
+        writeJson(io, {
+            command: "company.treasury-attest",
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleCompanyTreasuryReserve(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const companyDid = requireOption(args, "company-did");
+    const createdAt = getOptionalOption(args, "created-at") ?? now();
+    await withCliContext(dataDir, async (context) => {
+        const result = await appendEnvelope(context, {
+            objectKind: "company",
+            objectId: companyDid,
+            eventKind: "company.treasury-reserved",
+            subjectId: companyDid,
+            payload: {
+                reservationId: requireOption(args, "reservation-id"),
+                amountSats: parsePositiveInteger(requireOption(args, "amount-sats"), "--amount-sats"),
+                reason: requireOption(args, "reason"),
+                createdAt
+            }
+        });
+        writeJson(io, {
+            command: "company.treasury.reserve",
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleCompanyTreasuryRelease(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const companyDid = requireOption(args, "company-did");
+    await withCliContext(dataDir, async (context) => {
+        const result = await appendEnvelope(context, {
+            objectKind: "company",
+            objectId: companyDid,
+            eventKind: "company.treasury-released",
+            subjectId: companyDid,
+            payload: {
+                reservationId: requireOption(args, "reservation-id")
+            }
+        });
+        writeJson(io, {
+            command: "company.treasury.release",
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleMarketProductCreate(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    await withCliContext(dataDir, async (context) => {
+        const issuedAt = now();
+        const description = getOptionalOption(args, "description");
+        const payload = {
+            marketplaceId: requireOption(args, "marketplace"),
+            ownerDid: getOptionalOption(args, "owner-did") ?? context.identityMaterial.agentIdentity.did,
+            title: requireOption(args, "title"),
+            ...(description ? { description } : {})
+        };
+        const objectId = getOptionalOption(args, "id") ?? defaultObjectId("product", toProtocolValue({
+            actorDid: context.identityMaterial.agentIdentity.did,
+            issuedAt,
+            payload: toProtocolJsonObject(payload)
+        }));
+        const result = await appendEnvelope(context, {
+            objectKind: "product",
+            objectId,
+            eventKind: "product.created",
+            subjectId: objectId,
+            payload: toProtocolJsonObject(payload),
+            issuedAt
+        });
+        writeJson(io, {
+            command: "market.product.create",
+            objectId,
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleMarketProductUpdate(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const objectId = requireOption(args, "id");
+    const title = getOptionalOption(args, "title");
+    const description = getOptionalOption(args, "description");
+    if (title === undefined && description === undefined) {
+        throw new Error("At least one of --title or --description is required");
+    }
+    await withCliContext(dataDir, async (context) => {
+        const result = await appendEnvelope(context, {
+            objectKind: "product",
+            objectId,
+            eventKind: "product.updated",
+            subjectId: objectId,
+            payload: toProtocolJsonObject({
+                ...(title !== undefined ? { title } : {}),
+                ...(description !== undefined ? { description } : {})
+            })
+        });
+        writeJson(io, {
+            command: "market.product.update",
+            objectId,
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleMarketProductStateChange(args, io, eventKind) {
+    const dataDir = requireOption(args, "data-dir");
+    const objectId = requireOption(args, "id");
+    await withCliContext(dataDir, async (context) => {
+        const result = await appendEnvelope(context, {
+            objectKind: "product",
+            objectId,
+            eventKind,
+            subjectId: objectId,
+            payload: {}
+        });
+        writeJson(io, {
+            command: `market.product.${eventKind.split(".")[1]}`,
+            objectId,
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleMarketListingPublish(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    await withCliContext(dataDir, async (context) => {
+        const issuedAt = now();
+        const productId = getOptionalOption(args, "product-id");
+        const payload = {
+            marketplaceId: requireOption(args, "marketplace"),
+            sellerDid: getOptionalOption(args, "seller-did") ?? context.identityMaterial.agentIdentity.did,
+            title: requireOption(args, "title"),
+            ...(productId ? { productId } : {}),
+            paymentTerms: parsePaymentTerms(args)
+        };
+        const objectId = getOptionalOption(args, "id") ?? defaultObjectId("listing", toProtocolValue({
+            actorDid: context.identityMaterial.agentIdentity.did,
+            issuedAt,
+            payload: toProtocolJsonObject(payload)
+        }));
+        const result = await appendEnvelope(context, {
+            objectKind: "listing",
+            objectId,
+            eventKind: "listing.published",
+            subjectId: objectId,
+            payload: toProtocolJsonObject(payload),
+            issuedAt
+        });
+        writeJson(io, {
+            command: "market.listing.publish",
+            objectId,
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleMarketListingRevise(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const objectId = requireOption(args, "id");
+    await withCliContext(dataDir, async (context) => {
+        const state = await readRequiredState(context.repository, "listing", objectId);
+        const title = getOptionalOption(args, "title");
+        const paymentTerms = mergePaymentTerms(args, state.paymentTerms);
+        const result = await appendEnvelope(context, {
+            objectKind: "listing",
+            objectId,
+            eventKind: "listing.revised",
+            subjectId: objectId,
+            payload: toProtocolJsonObject({
+                ...(title !== undefined ? { title } : {}),
+                paymentTerms
+            })
+        });
+        writeJson(io, {
+            command: "market.listing.revise",
+            objectId,
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleSimpleMarketStateChange(args, io, objectKind, eventKind) {
+    const dataDir = requireOption(args, "data-dir");
+    const objectId = requireOption(args, "id");
+    await withCliContext(dataDir, async (context) => {
+        const result = await appendEnvelope(context, {
+            objectKind,
+            objectId,
+            eventKind,
+            subjectId: objectId,
+            payload: {}
+        });
+        writeJson(io, {
+            command: `market.${objectKind}.${eventKind.split(".")[1]}`,
+            objectId,
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleMarketRequestPublish(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    await withCliContext(dataDir, async (context) => {
+        const issuedAt = now();
+        const payload = {
+            marketplaceId: requireOption(args, "marketplace"),
+            requesterDid: getOptionalOption(args, "requester-did") ?? context.identityMaterial.agentIdentity.did,
+            title: requireOption(args, "title"),
+            paymentTerms: parsePaymentTerms(args)
+        };
+        const objectId = getOptionalOption(args, "id") ?? defaultObjectId("request", toProtocolValue({
+            actorDid: context.identityMaterial.agentIdentity.did,
+            issuedAt,
+            payload: toProtocolJsonObject(payload)
+        }));
+        const result = await appendEnvelope(context, {
+            objectKind: "request",
+            objectId,
+            eventKind: "request.published",
+            subjectId: objectId,
+            payload: toProtocolJsonObject(payload),
+            issuedAt
+        });
+        writeJson(io, {
+            command: "market.request.publish",
+            objectId,
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleMarketRequestRevise(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const objectId = requireOption(args, "id");
+    await withCliContext(dataDir, async (context) => {
+        const state = await readRequiredState(context.repository, "request", objectId);
+        const title = getOptionalOption(args, "title");
+        const paymentTerms = mergePaymentTerms(args, state.paymentTerms);
+        const result = await appendEnvelope(context, {
+            objectKind: "request",
+            objectId,
+            eventKind: "request.revised",
+            subjectId: objectId,
+            payload: toProtocolJsonObject({
+                ...(title !== undefined ? { title } : {}),
+                paymentTerms
+            })
+        });
+        writeJson(io, {
+            command: "market.request.revise",
+            objectId,
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleMarketOfferSubmit(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    await withCliContext(dataDir, async (context) => {
+        const issuedAt = now();
+        const targetObjectId = getOptionalOption(args, "target-object-id");
+        const lightningRefs = parseLightningRefs(args);
+        const payload = {
+            marketplaceId: requireOption(args, "marketplace"),
+            proposerDid: getOptionalOption(args, "proposer-did") ?? context.identityMaterial.agentIdentity.did,
+            ...(targetObjectId ? { targetObjectId } : {}),
+            paymentTerms: parsePaymentTerms(args),
+            ...(lightningRefs.length > 0 ? { lightningRefs } : {})
+        };
+        const objectId = getOptionalOption(args, "id") ?? defaultObjectId("offer", toProtocolValue({
+            actorDid: context.identityMaterial.agentIdentity.did,
+            issuedAt,
+            payload: toProtocolJsonObject(payload)
+        }));
+        const result = await appendEnvelope(context, {
+            objectKind: "offer",
+            objectId,
+            eventKind: "offer.submitted",
+            subjectId: objectId,
+            payload: toProtocolJsonObject(payload),
+            issuedAt
+        });
+        writeJson(io, {
+            command: "market.offer.submit",
+            objectId,
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleMarketOfferCounter(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const objectId = requireOption(args, "id");
+    await withCliContext(dataDir, async (context) => {
+        const state = await readRequiredState(context.repository, "offer", objectId);
+        const lightningRefs = parseLightningRefs(args);
+        const result = await appendEnvelope(context, {
+            objectKind: "offer",
+            objectId,
+            eventKind: "offer.countered",
+            subjectId: objectId,
+            payload: toProtocolJsonObject({
+                paymentTerms: mergePaymentTerms(args, state.paymentTerms),
+                ...(lightningRefs.length > 0 ? { lightningRefs } : {})
+            })
+        });
+        writeJson(io, {
+            command: "market.offer.counter",
+            objectId,
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleMarketBidSubmit(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    await withCliContext(dataDir, async (context) => {
+        const issuedAt = now();
+        const targetObjectId = getOptionalOption(args, "target-object-id");
+        const lightningRefs = parseLightningRefs(args);
+        const payload = {
+            marketplaceId: requireOption(args, "marketplace"),
+            proposerDid: getOptionalOption(args, "proposer-did") ?? context.identityMaterial.agentIdentity.did,
+            ...(targetObjectId ? { targetObjectId } : {}),
+            paymentTerms: parsePaymentTerms(args),
+            ...(lightningRefs.length > 0 ? { lightningRefs } : {})
+        };
+        const objectId = getOptionalOption(args, "id") ?? defaultObjectId("bid", toProtocolValue({
+            actorDid: context.identityMaterial.agentIdentity.did,
+            issuedAt,
+            payload: toProtocolJsonObject(payload)
+        }));
+        const result = await appendEnvelope(context, {
+            objectKind: "bid",
+            objectId,
+            eventKind: "bid.submitted",
+            subjectId: objectId,
+            payload: toProtocolJsonObject(payload),
+            issuedAt
+        });
+        writeJson(io, {
+            command: "market.bid.submit",
+            objectId,
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleMarketBidCounter(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const objectId = requireOption(args, "id");
+    await withCliContext(dataDir, async (context) => {
+        const state = await readRequiredState(context.repository, "bid", objectId);
+        const lightningRefs = parseLightningRefs(args);
+        const result = await appendEnvelope(context, {
+            objectKind: "bid",
+            objectId,
+            eventKind: "bid.countered",
+            subjectId: objectId,
+            payload: toProtocolJsonObject({
+                paymentTerms: mergePaymentTerms(args, state.paymentTerms),
+                ...(lightningRefs.length > 0 ? { lightningRefs } : {})
+            })
+        });
+        writeJson(io, {
+            command: "market.bid.counter",
+            objectId,
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+function deriveAgreementCounterparties(sourceKind, sourceState, actorDid, explicitCounterparties) {
+    if (explicitCounterparties.length > 0) {
+        return [...new Set(explicitCounterparties)].sort();
+    }
+    switch (sourceKind) {
+        case "offer":
+            return [...new Set([sourceState.proposerDid, actorDid])].sort();
+        case "bid":
+            return [...new Set([sourceState.proposerDid, actorDid])].sort();
+        case "listing":
+            return [...new Set([sourceState.sellerDid, actorDid])].sort();
+        case "request":
+            return [...new Set([sourceState.requesterDid, actorDid])].sort();
+    }
+}
+async function handleMarketAgreementCreate(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const sourceKind = parseEnum(requireOption(args, "source-kind"), "--source-kind", [
+        "offer",
+        "bid",
+        "listing",
+        "request"
+    ]);
+    const sourceObjectId = requireOption(args, "source-id");
+    await withCliContext(dataDir, async (context) => {
+        const issuedAt = now();
+        const sourceState = await readRequiredState(context.repository, sourceKind, sourceObjectId);
+        const marketplaceId = getOptionalOption(args, "marketplace") ?? sourceState.marketplaceId;
+        const paymentTerms = getOptionalOption(args, "amount-sats") || getOptionalOption(args, "currency") || getOptionalOption(args, "settlement")
+            ? mergePaymentTerms(args, sourceState.paymentTerms)
+            : sourceState.paymentTerms;
+        const deliverables = getCsvOptionValues(args, "deliverable");
+        if (deliverables.length === 0) {
+            throw new Error("At least one --deliverable is required");
+        }
+        const counterparties = deriveAgreementCounterparties(sourceKind, sourceState, context.identityMaterial.agentIdentity.did, getCsvOptionValues(args, "counterparty"));
+        const lightningRefs = parseLightningRefs(args);
+        const payload = {
+            marketplaceId,
+            sourceObjectKind: sourceKind,
+            sourceObjectId,
+            counterparties,
+            deliverables,
+            paymentTerms,
+            ...(lightningRefs.length > 0 ? { lightningRefs } : {})
+        };
+        const objectId = getOptionalOption(args, "id") ?? defaultObjectId("agreement", toProtocolValue({
+            actorDid: context.identityMaterial.agentIdentity.did,
+            issuedAt,
+            payload: toProtocolJsonObject(payload)
+        }));
+        const result = await appendEnvelope(context, {
+            objectKind: "agreement",
+            objectId,
+            eventKind: "agreement.created",
+            subjectId: objectId,
+            payload: toProtocolJsonObject(payload),
+            issuedAt
+        });
+        writeJson(io, {
+            command: "market.agreement.create",
+            objectId,
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleContractCreate(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    await withCliContext(dataDir, async (context) => {
+        const issuedAt = now();
+        const sponsorDid = getOptionalOption(args, "sponsor-did");
+        const companyDid = getOptionalOption(args, "company-did");
+        const payload = {
+            originRef: {
+                objectKind: parseEnum(requireOption(args, "origin-kind"), "--origin-kind", [
+                    "agreement",
+                    "listing",
+                    "request",
+                    "offer",
+                    "bid"
+                ]),
+                objectId: requireOption(args, "origin-id")
+            },
+            parties: getCsvOptionValues(args, "party"),
+            ...(sponsorDid ? { sponsorDid } : {}),
+            ...(companyDid ? { companyDid } : {}),
+            scope: requireOption(args, "scope"),
+            milestones: parseJsonOption(args, "milestones-json"),
+            deliverableSchema: parseJsonOption(args, "deliverable-schema-json"),
+            proofPolicy: parseJsonOption(args, "proof-policy-json"),
+            resolutionPolicy: parseJsonOption(args, "resolution-policy-json"),
+            settlementPolicy: parseJsonOption(args, "settlement-policy-json"),
+            deadlinePolicy: parseJsonOption(args, "deadline-policy-json")
+        };
+        if (payload.parties.length === 0) {
+            throw new Error("At least one --party is required");
+        }
+        const objectId = getOptionalOption(args, "id") ?? defaultObjectId("contract", toProtocolValue({
+            actorDid: context.identityMaterial.agentIdentity.did,
+            issuedAt,
+            payload: toProtocolJsonObject(payload)
+        }));
+        const result = await appendEnvelope(context, {
+            objectKind: "contract",
+            objectId,
+            eventKind: "contract.created",
+            subjectId: objectId,
+            payload: Protocol.contractCreatedPayloadToJson(payload),
+            issuedAt
+        });
+        writeJson(io, {
+            command: "contract.create",
+            objectId,
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleContractMilestoneAction(args, io, eventKind) {
+    const dataDir = requireOption(args, "data-dir");
+    const contractId = requireOption(args, "id");
+    const milestoneId = requireOption(args, "milestone-id");
+    await withCliContext(dataDir, async (context) => {
+        const payload = eventKind === "contract.milestone-opened"
+            ? { milestoneId }
+            : eventKind === "contract.milestone-rejected"
+                ? { milestoneId, reason: requireOption(args, "reason") }
+                : {
+                    milestoneId,
+                    ...(getUniqueOptionValues(args, "evidence-bundle-id").length > 0
+                        ? { evidenceBundleIds: getUniqueOptionValues(args, "evidence-bundle-id") }
+                        : {}),
+                    ...(getUniqueOptionValues(args, "oracle-attestation-id").length > 0
+                        ? { oracleAttestationIds: getUniqueOptionValues(args, "oracle-attestation-id") }
+                        : {})
+                };
+        const result = await appendEnvelope(context, {
+            objectKind: "contract",
+            objectId: contractId,
+            eventKind,
+            subjectId: contractId,
+            payload: toProtocolJsonObject(payload)
+        });
+        writeJson(io, {
+            command: `contract.${eventKind.split(".")[1]}`,
+            objectId: contractId,
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleContractStateChange(args, io, eventKind) {
+    const dataDir = requireOption(args, "data-dir");
+    const contractId = requireOption(args, "id");
+    await withCliContext(dataDir, async (context) => {
+        const result = await appendEnvelope(context, {
+            objectKind: "contract",
+            objectId: contractId,
+            eventKind,
+            subjectId: contractId,
+            payload: {}
+        });
+        writeJson(io, {
+            command: `contract.${eventKind.split(".")[1]}`,
+            objectId: contractId,
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleEvidenceRecord(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    await withCliContext(dataDir, async (context) => {
+        const issuedAt = now();
+        const artifactRefs = getOptionalOption(args, "artifact-json")
+            ? parseJsonOption(args, "artifact-json")
+            : [];
+        const verifierRefs = getOptionalOption(args, "verifier-json")
+            ? parseJsonOption(args, "verifier-json")
+            : [];
+        const reproInstructions = getOptionalOption(args, "repro");
+        const executionTranscriptRefs = getUniqueOptionValues(args, "execution-transcript-ref");
+        const hashes = Object.fromEntries(getUniqueOptionValues(args, "hash").map((entry) => {
+            const [name, hash] = entry.split("=", 2);
+            if (!name || !hash) {
+                throw new Error("--hash must use <name>=<hex-hash>");
+            }
+            return [name, hash];
+        }));
+        const payload = {
+            contractId: requireOption(args, "contract-id"),
+            milestoneId: requireOption(args, "milestone-id"),
+            submitterDid: context.identityMaterial.agentIdentity.did,
+            artifactRefs,
+            verifierRefs,
+            proofModes: getCsvOptionValues(args, "proof-mode"),
+            ...(reproInstructions ? { reproInstructions } : {}),
+            hashes,
+            executionTranscriptRefs
+        };
+        const objectId = getOptionalOption(args, "id") ?? defaultObjectId("evidence-bundle", toProtocolValue({
+            actorDid: context.identityMaterial.agentIdentity.did,
+            issuedAt,
+            payload: toProtocolJsonObject(payload)
+        }));
+        const result = await appendEnvelope(context, {
+            objectKind: "evidence-bundle",
+            objectId,
+            eventKind: "evidence-bundle.recorded",
+            subjectId: objectId,
+            payload: Protocol.evidenceBundlePayloadToJson(payload),
+            issuedAt
+        });
+        writeJson(io, {
+            command: "evidence.record",
+            objectId,
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleOracleAttest(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    await withCliContext(dataDir, async (context) => {
+        const issuedAt = getOptionalOption(args, "issued-at") ?? now();
+        const milestoneId = getOptionalOption(args, "milestone-id");
+        const payload = {
+            oracleDid: context.identityMaterial.agentIdentity.did,
+            claimType: requireOption(args, "claim-type"),
+            subjectRef: {
+                objectKind: parseEnum(requireOption(args, "subject-kind"), "--subject-kind", [
+                    "contract",
+                    "evidence-bundle",
+                    "dispute-case"
+                ]),
+                objectId: requireOption(args, "subject-id"),
+                ...(milestoneId ? { milestoneId } : {})
+            },
+            outcome: parseEnum(requireOption(args, "outcome"), "--outcome", [
+                "satisfied",
+                "unsatisfied",
+                "accepted",
+                "rejected",
+                "completed",
+                "breached"
+            ]),
+            evidenceRefs: getUniqueOptionValues(args, "evidence-ref"),
+            issuedAt,
+            expiresAt: requireOption(args, "expires-at")
+        };
+        const objectId = getOptionalOption(args, "id") ?? defaultObjectId("oracle-attestation", toProtocolValue({
+            actorDid: context.identityMaterial.agentIdentity.did,
+            issuedAt,
+            payload: toProtocolJsonObject(payload)
+        }));
+        const result = await appendEnvelope(context, {
+            objectKind: "oracle-attestation",
+            objectId,
+            eventKind: "oracle-attestation.recorded",
+            subjectId: objectId,
+            payload: Protocol.oracleAttestationPayloadToJson(payload),
+            issuedAt
+        });
+        writeJson(io, {
+            command: "oracle.attest",
+            objectId,
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleDisputeOpen(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    await withCliContext(dataDir, async (context) => {
+        const issuedAt = now();
+        const payload = {
+            contractId: requireOption(args, "contract-id"),
+            ...(getOptionalOption(args, "milestone-id") ? { milestoneId: getOptionalOption(args, "milestone-id") } : {}),
+            reason: requireOption(args, "reason")
+        };
+        const objectId = getOptionalOption(args, "id") ?? defaultObjectId("dispute-case", toProtocolValue({
+            actorDid: context.identityMaterial.agentIdentity.did,
+            issuedAt,
+            payload: toProtocolJsonObject(payload)
+        }));
+        const result = await appendEnvelope(context, {
+            objectKind: "dispute-case",
+            objectId,
+            eventKind: "dispute.opened",
+            subjectId: objectId,
+            payload: toProtocolJsonObject(payload),
+            issuedAt
+        });
+        writeJson(io, {
+            command: "dispute.open",
+            objectId,
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleDisputeAddEvidence(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const objectId = requireOption(args, "id");
+    await withCliContext(dataDir, async (context) => {
+        const evidenceBundleIds = getUniqueOptionValues(args, "evidence-bundle-id");
+        if (evidenceBundleIds.length === 0) {
+            throw new Error("At least one --evidence-bundle-id is required");
+        }
+        const result = await appendEnvelope(context, {
+            objectKind: "dispute-case",
+            objectId,
+            eventKind: "dispute.evidence-added",
+            subjectId: objectId,
+            payload: {
+                evidenceBundleIds
+            }
+        });
+        writeJson(io, {
+            command: "dispute.add-evidence",
+            objectId,
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleDisputeRequestOracle(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const objectId = requireOption(args, "id");
+    await withCliContext(dataDir, async (context) => {
+        const result = await appendEnvelope(context, {
+            objectKind: "dispute-case",
+            objectId,
+            eventKind: "dispute.oracle-requested",
+            subjectId: objectId,
+            payload: {}
+        });
+        writeJson(io, {
+            command: "dispute.request-oracle",
+            objectId,
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleDisputeRule(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const objectId = requireOption(args, "id");
+    await withCliContext(dataDir, async (context) => {
+        const deterministicVerifierId = getOptionalOption(args, "deterministic-verifier-id");
+        const summary = getOptionalOption(args, "summary");
+        const ruling = {
+            outcome: parseEnum(requireOption(args, "outcome"), "--outcome", [
+                "fulfilled",
+                "breach",
+                "refund",
+                "partial",
+                "rejected-claim"
+            ]),
+            resolutionMode: parseEnum(requireOption(args, "resolution-mode"), "--resolution-mode", [
+                "deterministic",
+                "oracle",
+                "mutual",
+                "hybrid"
+            ]),
+            ...(deterministicVerifierId ? { deterministicVerifierId } : {}),
+            oracleAttestationIds: getUniqueOptionValues(args, "oracle-attestation-id"),
+            evidenceBundleIds: getUniqueOptionValues(args, "evidence-bundle-id"),
+            approverDids: getCsvOptionValues(args, "approver"),
+            ...(summary ? { summary } : {})
+        };
+        const result = await appendEnvelope(context, {
+            objectKind: "dispute-case",
+            objectId,
+            eventKind: "dispute.ruled",
+            subjectId: objectId,
+            payload: Protocol.disputeRulingToJson(ruling)
+        });
+        writeJson(io, {
+            command: "dispute.rule",
+            objectId,
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleDisputeClose(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const objectId = requireOption(args, "id");
+    await withCliContext(dataDir, async (context) => {
+        const result = await appendEnvelope(context, {
+            objectKind: "dispute-case",
+            objectId,
+            eventKind: "dispute.closed",
+            subjectId: objectId,
+            payload: {}
+        });
+        writeJson(io, {
+            command: "dispute.close",
+            objectId,
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleSpaceCreate(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    await withCliContext(dataDir, async (context) => {
+        const issuedAt = now();
+        const spaceId = getOptionalOption(args, "id") ?? defaultObjectId("space", toProtocolValue({
+            actorDid: context.identityMaterial.agentIdentity.did,
+            issuedAt,
+            ownerRef: {
+                kind: requireOption(args, "owner-kind"),
+                id: requireOption(args, "owner-id")
+            }
+        }));
+        const membershipPolicy = getOptionalOption(args, "membership-policy-json")
+            ? parseJsonOption(args, "membership-policy-json")
+            : {
+                mode: "invite-only",
+                ownerMemberDids: [context.identityMaterial.agentIdentity.did]
+            };
+        const encryptionPolicy = getOptionalOption(args, "encryption-policy-json")
+            ? parseJsonOption(args, "encryption-policy-json")
+            : {
+                mode: "member-sealed-box",
+                keyAgreementMethod: "did-keyagreement-v1"
+            };
+        const payload = {
+            spaceKind: parseEnum(requireOption(args, "space-kind"), "--space-kind", [
+                "direct-inbox",
+                "contract-thread",
+                "company-room",
+                "market-room"
+            ]),
+            ownerRef: {
+                kind: parseEnum(requireOption(args, "owner-kind"), "--owner-kind", [
+                    "agent",
+                    "company",
+                    "marketplace",
+                    "contract",
+                    "dispute"
+                ]),
+                id: requireOption(args, "owner-id")
+            },
+            membershipPolicy,
+            encryptionPolicy
+        };
+        const created = await appendEnvelope(context, {
+            objectKind: "space",
+            objectId: spaceId,
+            eventKind: "space.created",
+            subjectId: spaceId,
+            payload: Protocol.spacePayloadToJson(payload),
+            issuedAt
+        });
+        const membershipObjectId = `${spaceId}:${context.identityMaterial.agentIdentity.did}`;
+        await appendEnvelope(context, {
+            objectKind: "space-membership",
+            objectId: membershipObjectId,
+            eventKind: "space-membership.member-added",
+            subjectId: membershipObjectId,
+            payload: Protocol.spaceMembershipPayloadToJson({
+                spaceId,
+                memberDid: context.identityMaterial.agentIdentity.did,
+                role: "owner"
+            })
+        });
+        writeJson(io, {
+            command: "space.create",
+            objectId: spaceId,
+            eventId: created.envelope.eventId,
+            state: created.state
+        });
+    });
+}
+async function handleSpaceMembershipAction(args, io, eventKind) {
+    const dataDir = requireOption(args, "data-dir");
+    const spaceId = requireOption(args, "space-id");
+    const memberDid = requireOption(args, "member-did");
+    const objectId = getOptionalOption(args, "id") ?? `${spaceId}:${memberDid}`;
+    await withCliContext(dataDir, async (context) => {
+        const payload = eventKind === "space-membership.member-added"
+            ? Protocol.spaceMembershipPayloadToJson({
+                spaceId,
+                memberDid,
+                role: parseEnum(getOptionalOption(args, "role") ?? "member", "--role", [
+                    "owner",
+                    "moderator",
+                    "member"
+                ])
+            })
+            : eventKind === "space-membership.member-role-updated"
+                ? toProtocolJsonObject({
+                    role: parseEnum(requireOption(args, "role"), "--role", ["owner", "moderator", "member"])
+                })
+                : {};
+        const result = await appendEnvelope(context, {
+            objectKind: "space-membership",
+            objectId,
+            eventKind,
+            subjectId: objectId,
+            payload
+        });
+        writeJson(io, {
+            command: `space.${eventKind.split(".")[1]}`,
+            objectId,
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleMessageSend(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    await withCliContext(dataDir, async (context) => {
+        const issuedAt = now();
+        const spaceId = requireOption(args, "space-id");
+        const activeMemberDids = listActiveSpaceMemberDids(context, spaceId);
+        if (activeMemberDids.length === 0) {
+            throw new Error("The target space has no active members");
+        }
+        const encryptedBody = await Protocol.encryptMessageForRecipients({
+            plaintext: requireOption(args, "body"),
+            senderDid: context.identityMaterial.agentIdentity.did,
+            senderKeyAgreementPublicKey: context.identityMaterial.agentIdentity.keyAgreementPublicKey,
+            senderKeyAgreementSecretKey: context.identityMaterial.keyAgreementKeyPair.secretKey,
+            recipientDids: activeMemberDids
+        });
+        const payload = {
+            spaceId,
+            messageType: getOptionalOption(args, "message-type") ?? "text",
+            metadata: getOptionalOption(args, "metadata-json")
+                ? parseJsonOption(args, "metadata-json")
+                : {},
+            encryptedBody,
+            sentAt: issuedAt
+        };
+        const objectId = getOptionalOption(args, "id") ?? defaultObjectId("message", toProtocolValue({
+            actorDid: context.identityMaterial.agentIdentity.did,
+            issuedAt,
+            payload: toProtocolJsonObject(payload)
+        }));
+        const result = await appendEnvelope(context, {
+            objectKind: "message",
+            objectId,
+            eventKind: "message.sent",
+            subjectId: objectId,
+            payload: Protocol.messageSentPayloadToJson(payload),
+            issuedAt
+        });
+        writeJson(io, {
+            command: "message.send",
+            objectId,
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleMessageEdit(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const objectId = requireOption(args, "id");
+    await withCliContext(dataDir, async (context) => {
+        const current = await readRequiredState(context.repository, "message", objectId);
+        const activeMemberDids = listActiveSpaceMemberDids(context, current.spaceId);
+        const encryptedBody = await Protocol.encryptMessageForRecipients({
+            plaintext: requireOption(args, "body"),
+            senderDid: context.identityMaterial.agentIdentity.did,
+            senderKeyAgreementPublicKey: context.identityMaterial.agentIdentity.keyAgreementPublicKey,
+            senderKeyAgreementSecretKey: context.identityMaterial.keyAgreementKeyPair.secretKey,
+            recipientDids: activeMemberDids
+        });
+        const result = await appendEnvelope(context, {
+            objectKind: "message",
+            objectId,
+            eventKind: "message.edited",
+            subjectId: objectId,
+            payload: Protocol.messageSentPayloadToJson({
+                spaceId: current.spaceId,
+                messageType: current.messageType,
+                metadata: getOptionalOption(args, "metadata-json")
+                    ? parseJsonOption(args, "metadata-json")
+                    : current.metadata,
+                encryptedBody
+            })
+        });
+        writeJson(io, {
+            command: "message.edit",
+            objectId,
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleMessageDelete(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const objectId = requireOption(args, "id");
+    await withCliContext(dataDir, async (context) => {
+        const result = await appendEnvelope(context, {
+            objectKind: "message",
+            objectId,
+            eventKind: "message.deleted",
+            subjectId: objectId,
+            payload: {}
+        });
+        writeJson(io, {
+            command: "message.delete",
+            objectId,
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleMessageReact(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const objectId = requireOption(args, "id");
+    await withCliContext(dataDir, async (context) => {
+        const result = await appendEnvelope(context, {
+            objectKind: "message",
+            objectId,
+            eventKind: "message.reacted",
+            subjectId: objectId,
+            payload: {
+                reaction: requireOption(args, "reaction")
+            }
+        });
+        writeJson(io, {
+            command: "message.react",
+            objectId,
+            eventId: result.envelope.eventId,
+            state: result.state
+        });
+    });
+}
+async function handleContractEntries(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const contractId = requireOption(args, "id");
+    await withCliContext(dataDir, async (context) => {
+        writeJson(io, {
+            command: "contract.entries",
+            contractId,
+            entries: await context.repository.listContractEntries(contractId)
+        });
+    });
+}
+async function handleSpaceEntries(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const spaceId = requireOption(args, "space-id");
+    await withCliContext(dataDir, async (context) => {
+        writeJson(io, {
+            command: "space.entries",
+            spaceId,
+            entries: await context.repository.listSpaceEntries(spaceId)
+        });
+    });
+}
+async function handleObjectShow(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const kind = parseEnum(requireOption(args, "kind"), "--kind", [
+        "agent-profile",
+        "company",
+        "product",
+        "listing",
+        "request",
+        "offer",
+        "bid",
+        "agreement",
+        "feedback-credential-ref",
+        "contract",
+        "evidence-bundle",
+        "oracle-attestation",
+        "dispute-case",
+        "space",
+        "space-membership",
+        "message"
+    ]);
+    const objectId = requireOption(args, "id");
+    await withCliContext(dataDir, async (context) => {
+        writeJson(io, {
+            command: "object.show",
+            kind,
+            objectId,
+            state: await context.repository.readObjectState(kind, objectId)
+        });
+    });
+}
+async function handleMarketList(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const marketplaceId = requireOption(args, "marketplace");
+    await withCliContext(dataDir, async (context) => {
+        writeJson(io, {
+            command: "market.list",
+            marketplaceId,
+            entries: await context.repository.listMarketplaceEntries(marketplaceId)
+        });
+    });
+}
+async function handleServe(args, io) {
+    const dataDir = requireOption(args, "data-dir");
+    const logLevel = parseEnum(getOptionalOption(args, "log-level") ?? "info", "--log-level", [
+        "debug",
+        "info",
+        "warn",
+        "error"
+    ]);
+    const bootstrap = getCsvOptionValues(args, "bootstrap");
+    const marketplaces = getCsvOptionValues(args, "marketplace");
+    const companyIds = getCsvOptionValues(args, "company");
+    const connectDids = getCsvOptionValues(args, "connect-did");
+    const connectNoiseKeys = getCsvOptionValues(args, "connect-noise-key");
+    const exitAfterMs = getOptionalOption(args, "exit-after-ms");
+    const watchProtocol = !hasFlag(args, "no-watch-protocol");
+    const transportConfig = {
+        dataDir,
+        logLevel,
+        ...(bootstrap.length > 0 ? { bootstrap } : {})
+    };
+    const transport = await AgentTransport.create(transportConfig);
+    const topics = [];
+    const seenControlLengths = new Map();
+    const discoveryIntervalMs = 2_000;
+    let discoveryInterval;
+    try {
+        await transport.start();
+        if (hasFlag(args, "agent-topic")) {
+            topics.push({ kind: "agent", agentDid: transport.identity.did });
+        }
+        for (const marketplaceId of marketplaces) {
+            topics.push({ kind: "marketplace", marketplaceId });
+        }
+        for (const companyId of companyIds) {
+            topics.push({ kind: "company", companyId });
+        }
+        for (const topic of topics) {
+            await transport.joinTopic(topic);
+        }
+        for (const did of connectDids) {
+            await transport.connectToDid(did);
+        }
+        for (const publicKey of connectNoiseKeys) {
+            await transport.connectToNoiseKey(publicKey);
+        }
+        writeJson(io, {
+            command: "serve",
+            identity: transport.identity,
+            topics,
+            connectedPeers: [...transport.getPeerSessions().values()]
+        });
+        if (watchProtocol) {
+            discoveryInterval = setInterval(() => {
+                void (async () => {
+                    for (const session of transport.getPeerSessions().values()) {
+                        const remoteFeed = transport.getRemoteFeed(session.remoteControlFeedKey);
+                        if (!remoteFeed) {
+                            continue;
+                        }
+                        await remoteFeed.update({ wait: false });
+                        const seenLength = seenControlLengths.get(session.remoteControlFeedKey) ?? 0;
+                        if (remoteFeed.length <= seenLength) {
+                            continue;
+                        }
+                        for (let index = seenLength; index < remoteFeed.length; index += 1) {
+                            const entry = await remoteFeed.get(index);
+                            if (Protocol.isProtocolAnnouncement(entry)) {
+                                io.stdout(`${JSON.stringify({ command: "serve.discovery", remoteDid: session.remoteDid, announcement: entry }, null, 2)}\n`);
+                            }
+                        }
+                        seenControlLengths.set(session.remoteControlFeedKey, remoteFeed.length);
+                    }
+                })().catch((error) => {
+                    io.stderr(`${error instanceof Error ? error.message : String(error)}\n`);
+                });
+            }, discoveryIntervalMs);
+        }
+        if (exitAfterMs) {
+            await sleep(parsePositiveInteger(exitAfterMs, "--exit-after-ms"));
+            return;
+        }
+        await Promise.race([once(process, "SIGINT"), once(process, "SIGTERM")]);
+    }
+    finally {
+        if (discoveryInterval) {
+            clearInterval(discoveryInterval);
+        }
+        await transport.stop();
+    }
+}
+function usage() {
+    return [
+        "Usage:",
+        "  emporion agent init --data-dir <path> [--display-name <name>] [--bio <text>]",
+        "  emporion agent show --data-dir <path>",
+        "  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>",
+        "  emporion company create --data-dir <path> --name <name> [--description <text>]",
+        "  emporion company update --data-dir <path> --company-did <did> [--name <name>] [--description <text>]",
+        "  emporion company grant-role --data-dir <path> --company-did <did> --member-did <did> --role <owner|operator|member>",
+        "  emporion company treasury-attest --data-dir <path> --company-did <did> --attestation-id <id> --wallet-account-id <id> --balance-sats <n> --expires-at <iso>",
+        "  emporion market product create --data-dir <path> --marketplace <id> --title <title>",
+        "  emporion market listing publish --data-dir <path> --marketplace <id> --title <title> --amount-sats <n>",
+        "  emporion market request publish --data-dir <path> --marketplace <id> --title <title> --amount-sats <n>",
+        "  emporion market offer submit --data-dir <path> --marketplace <id> --amount-sats <n>",
+        "  emporion market bid submit --data-dir <path> --marketplace <id> --amount-sats <n>",
+        "  emporion market agreement create --data-dir <path> --source-kind <offer|bid|listing|request> --source-id <id> --deliverable <text>",
+        "  emporion contract create --data-dir <path> --origin-kind <kind> --origin-id <id> --party <did>[,<did>...] --scope <text> --milestones-json <json> --deliverable-schema-json <json> --proof-policy-json <json> --resolution-policy-json <json> --settlement-policy-json <json> --deadline-policy-json <json>",
+        "  emporion evidence record --data-dir <path> --contract-id <id> --milestone-id <id> --proof-mode <mode>[,<mode>...] [--artifact-json <json>] [--verifier-json <json>]",
+        "  emporion oracle attest --data-dir <path> --claim-type <type> --subject-kind <kind> --subject-id <id> --outcome <outcome> --expires-at <iso>",
+        "  emporion dispute open --data-dir <path> --contract-id <id> --reason <text>",
+        "  emporion space create --data-dir <path> --space-kind <kind> --owner-kind <kind> --owner-id <id>",
+        "  emporion message send --data-dir <path> --space-id <id> --body <text>",
+        "  emporion market list --data-dir <path> --marketplace <id>",
+        "  emporion object show --data-dir <path> --kind <kind> --id <id>",
+        "  emporion serve --data-dir <path> [--marketplace <id>] [--company <did>] [--agent-topic]"
+    ].join("\n");
+}
+export async function runCli(argv, io = DEFAULT_IO) {
+    try {
+        const args = parseArgs(argv);
+        if (args.commandPath.length === 0 || hasFlag(args, "help")) {
+            io.stdout(`${usage()}\n`);
+            return 0;
+        }
+        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);
+        if (commandMatches(args.commandPath, "serve"))
+            return await handleServe(args, io).then(() => 0);
+        throw new Error(`Unknown command: ${args.commandPath.join(" ")}`);
+    }
+    catch (error) {
+        io.stderr(`${error instanceof Error ? error.message : String(error)}\n`);
+        return 1;
+    }
+}
+const executedPath = process.argv[1] ? new URL(`file://${process.argv[1]}`).href : "";
+if (import.meta.url === executedPath) {
+    void runCli(process.argv.slice(2)).then((exitCode) => {
+        process.exitCode = exitCode;
+    });
+}
+//# sourceMappingURL=cli.js.map