@garydevenay/emporion 0.0.1 → 0.0.3

package/dist/src/cli.js

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