npm - @consiliency/agent-board-cli - Versions diffs - 1.2.0 - Mend

@consiliency/agent-board-cli 1.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/dist/cli.js ADDED Viewed

@@ -0,0 +1,1239 @@
+import { Command, Option } from "commander";
+import { createAgentBoardClient, toOperationFailure, } from "@consiliency/agent-board-client";
+function isRuntimeStatus(value) {
+    return Boolean(value && typeof value === "object" && "runtime" in value);
+}
+function parseJson(value) {
+    if (!value) {
+        return undefined;
+    }
+    return JSON.parse(value);
+}
+function numberOption(flags, description) {
+    return new Option(flags, description).argParser((value) => Number(value));
+}
+async function runHandler(io, operation, action) {
+    try {
+        const result = await action();
+        io.writeStdout(`${JSON.stringify(result, null, 2)}\n`);
+    }
+    catch (error) {
+        io.writeStdout(`${JSON.stringify(toOperationFailure(operation, error), null, 2)}\n`);
+        process.exitCode = 1;
+    }
+}
+async function runJsonlHandler(io, operation, action) {
+    try {
+        io.writeStdout(`${JSON.stringify(await action())}\n`);
+    }
+    catch (error) {
+        io.writeStdout(`${JSON.stringify(toOperationFailure(operation, error))}\n`);
+        process.exitCode = 1;
+    }
+}
+function jsonOption(flags, description) {
+    return new Option(flags, description).argParser((value) => parseJson(value));
+}
+export function signingStatusFromEnv(env = process.env) {
+    const keyIdName = env.MESSAGE_BOARD_SIGNING_KEY_ID
+        ? "MESSAGE_BOARD_SIGNING_KEY_ID"
+        : env.AGENT_BOARD_SIGNING_KEY_ID
+            ? "AGENT_BOARD_SIGNING_KEY_ID"
+            : null;
+    const keyVersionName = env.MESSAGE_BOARD_SIGNING_KEY_VERSION
+        ? "MESSAGE_BOARD_SIGNING_KEY_VERSION"
+        : env.AGENT_BOARD_SIGNING_KEY_VERSION
+            ? "AGENT_BOARD_SIGNING_KEY_VERSION"
+            : null;
+    const fingerprintName = env.MESSAGE_BOARD_SIGNING_PUBLIC_KEY_FINGERPRINT
+        ? "MESSAGE_BOARD_SIGNING_PUBLIC_KEY_FINGERPRINT"
+        : env.AGENT_BOARD_SIGNING_PUBLIC_KEY_FINGERPRINT
+            ? "AGENT_BOARD_SIGNING_PUBLIC_KEY_FINGERPRINT"
+            : null;
+    const privateKeyName = env.MESSAGE_BOARD_SIGNING_PRIVATE_KEY
+        ? "MESSAGE_BOARD_SIGNING_PRIVATE_KEY"
+        : env.AGENT_BOARD_SIGNING_PRIVATE_KEY
+            ? "AGENT_BOARD_SIGNING_PRIVATE_KEY"
+            : null;
+    return {
+        ok: true,
+        operation: "agent_board.signing_status",
+        signing: {
+            mode: keyIdName && keyVersionName && privateKeyName ? "signed" : "unsigned_compatibility",
+            keyId: keyIdName ? env[keyIdName] : null,
+            keyVersion: keyVersionName ? Number(env[keyVersionName]) : null,
+            algorithm: "Ed25519",
+            publicKeyFingerprint: fingerprintName ? env[fingerprintName] : null,
+            privateKeySource: privateKeyName,
+            privateKeyAvailable: Boolean(privateKeyName),
+            canonicalizationVersion: "agent-provenance-jcs.v1",
+            redacted: true,
+        },
+    };
+}
+async function runRuntimeDoctor(io, client, requireRuntime) {
+    await runHandler(io, "agent_board.runtime_doctor", async () => {
+        const status = await client.runtimeStatus();
+        if (requireRuntime &&
+            isRuntimeStatus(status) &&
+            (!status.runtime?.ready || status.runtime.directFallback)) {
+            throw new Error(status.runtime?.fallbackReason ?? "missing_runtime");
+        }
+        return {
+            ...status,
+            operation: "agent_board.runtime_doctor",
+        };
+    });
+}
+function recipientOption(flags, description) {
+    return new Option(flags, description).argParser((value) => {
+        const parsed = parseJson(value);
+        if (!parsed) {
+            return undefined;
+        }
+        return parsed;
+    });
+}
+function addWriteCommands(program, client, io) {
+    program
+        .command("resolve-recipients")
+        .option("--actor-agent-id <agentId>")
+        .addOption(recipientOption("--recipients <json>", "recipient descriptors JSON array").makeOptionMandatory())
+        .action((options) => runHandler(io, "agent_board.resolve_recipients", () => client.resolveRecipients({
+        actorAgentId: options.actorAgentId,
+        recipients: options.recipients,
+    })));
+    program
+        .command("expand-recipients-dry-run")
+        .option("--actor-agent-id <agentId>")
+        .option("--thread-idempotency-key <key>")
+        .addOption(recipientOption("--recipients <json>", "recipient descriptors JSON array").makeOptionMandatory())
+        .action((options) => runHandler(io, "agent_board.expand_recipients_dry_run", () => client.expandRecipientsDryRun({
+        actorAgentId: options.actorAgentId,
+        recipients: options.recipients,
+        threadIdempotencyKey: options.threadIdempotencyKey,
+    })));
+    program
+        .command("create-or-find-thread")
+        .option("--created-by-agent-id <agentId>")
+        .requiredOption("--subject <subject>")
+        .requiredOption("--idempotency-key <key>")
+        .option("--thread-type <threadType>")
+        .addOption(jsonOption("--metadata <json>", "thread metadata"))
+        .action((options) => runHandler(io, "agent_board.create_or_find_thread", () => client.createOrFindThread({
+        createdByAgentId: options.createdByAgentId,
+        subject: options.subject,
+        idempotencyKey: options.idempotencyKey,
+        threadType: options.threadType,
+        metadata: options.metadata,
+    })));
+    const send = program.command("send").description("ergonomic send commands");
+    send
+        .command("direct")
+        .option("--thread-id <threadId>")
+        .option("--thread <json>")
+        .option("--author-agent-id <agentId>")
+        .addOption(recipientOption("--recipient <json>", "recipient descriptor").makeOptionMandatory())
+        .requiredOption("--subject <subject>")
+        .requiredOption("--body <body>")
+        .option("--message-type <messageType>")
+        .option("--priority <priority>")
+        .option("--idempotency-key <idempotencyKey>")
+        .option("--dry-run")
+        .addOption(jsonOption("--metadata <json>", "direct message metadata"))
+        .action((options) => runHandler(io, "agent_board.send_direct", () => client.sendDirect({
+        threadId: options.threadId,
+        thread: parseJson(options.thread),
+        authorAgentId: options.authorAgentId,
+        recipient: options.recipient,
+        subject: options.subject,
+        body: options.body,
+        messageType: options.messageType,
+        priority: options.priority,
+        idempotencyKey: options.idempotencyKey,
+        dryRun: Boolean(options.dryRun),
+        metadata: options.metadata,
+    })));
+    send
+        .command("multicast")
+        .option("--thread-id <threadId>")
+        .option("--thread <json>")
+        .option("--author-agent-id <agentId>")
+        .addOption(recipientOption("--recipients <json>", "recipient descriptors JSON array").makeOptionMandatory())
+        .requiredOption("--subject <subject>")
+        .requiredOption("--body <body>")
+        .option("--message-type <messageType>")
+        .option("--priority <priority>")
+        .option("--idempotency-key <idempotencyKey>")
+        .option("--dry-run")
+        .addOption(jsonOption("--metadata <json>", "multicast message metadata"))
+        .action((options) => runHandler(io, "agent_board.send_multicast", () => client.sendMulticast({
+        threadId: options.threadId,
+        thread: parseJson(options.thread),
+        authorAgentId: options.authorAgentId,
+        recipients: options.recipients,
+        subject: options.subject,
+        body: options.body,
+        messageType: options.messageType,
+        priority: options.priority,
+        idempotencyKey: options.idempotencyKey,
+        dryRun: Boolean(options.dryRun),
+        metadata: options.metadata,
+    })));
+    const post = program.command("post").description("ergonomic post commands");
+    post
+        .command("board")
+        .option("--thread-id <threadId>")
+        .option("--thread <json>")
+        .option("--author-agent-id <agentId>")
+        .option("--board-id <boardId>")
+        .option("--board-slug <boardSlug>")
+        .requiredOption("--subject <subject>")
+        .requiredOption("--body <body>")
+        .option("--message-type <messageType>")
+        .option("--priority <priority>")
+        .option("--idempotency-key <idempotencyKey>")
+        .addOption(jsonOption("--metadata <json>", "board post metadata"))
+        .action((options) => runHandler(io, "agent_board.post_board", () => client.postBoard({
+        threadId: options.threadId,
+        thread: parseJson(options.thread),
+        authorAgentId: options.authorAgentId,
+        boardId: options.boardId,
+        boardSlug: options.boardSlug,
+        subject: options.subject,
+        body: options.body,
+        messageType: options.messageType,
+        priority: options.priority,
+        idempotencyKey: options.idempotencyKey,
+        metadata: options.metadata,
+    })));
+    const create = program.command("create").description("ergonomic create commands");
+    create
+        .command("tasking")
+        .option("--thread-id <threadId>")
+        .option("--thread <json>")
+        .option("--author-agent-id <agentId>")
+        .addOption(recipientOption("--recipients <json>", "recipient descriptors JSON array"))
+        .option("--board-id <boardId>")
+        .option("--board-slug <boardSlug>")
+        .requiredOption("--title <title>")
+        .option("--details <details>")
+        .option("--priority <priority>")
+        .option("--orchestration-mode <orchestrationMode>")
+        .option("--idempotency-key <idempotencyKey>")
+        .option("--dry-run")
+        .addOption(jsonOption("--metadata <json>", "tasking metadata"))
+        .action((options) => runHandler(io, "agent_board.create_tasking", () => client.createTasking({
+        threadId: options.threadId,
+        thread: parseJson(options.thread),
+        authorAgentId: options.authorAgentId,
+        recipients: options.recipients,
+        boardId: options.boardId,
+        boardSlug: options.boardSlug,
+        subject: options.title,
+        title: options.title,
+        details: options.details,
+        priority: options.priority,
+        orchestrationMode: options.orchestrationMode,
+        idempotencyKey: options.idempotencyKey,
+        dryRun: Boolean(options.dryRun),
+        metadata: options.metadata,
+    })));
+    program
+        .command("register-agent")
+        .requiredOption("--agent-type <agentType>")
+        .requiredOption("--handle <handle>")
+        .requiredOption("--display-name <displayName>")
+        .option("--status <status>")
+        .addOption(jsonOption("--metadata <json>", "agent metadata"))
+        .action((options) => runHandler(io, "agent_board.register_agent", () => client.registerAgent({
+        p_agent_type: options.agentType,
+        p_handle: options.handle,
+        p_display_name: options.displayName,
+        p_status: options.status,
+        p_metadata: options.metadata,
+    })));
+    program
+        .command("heartbeat")
+        .option("--agent-id <agentId>")
+        .option("--thread-id <threadId>")
+        .option("--availability <availability>")
+        .option("--activity-summary <activitySummary>")
+        .option("--expires-in <expiresIn>")
+        .addOption(jsonOption("--metadata <json>", "heartbeat metadata"))
+        .action((options) => runHandler(io, "agent_board.heartbeat", () => client.heartbeat({
+        p_agent_id: options.agentId,
+        p_thread_id: options.threadId,
+        p_availability: options.availability,
+        p_activity_summary: options.activitySummary,
+        p_expires_in: options.expiresIn,
+        p_metadata: options.metadata,
+    })));
+    program
+        .command("create-thread")
+        .option("--created-by-agent-id <agentId>")
+        .requiredOption("--subject <subject>")
+        .option("--thread-type <threadType>")
+        .addOption(jsonOption("--metadata <json>", "thread metadata"))
+        .action((options) => runHandler(io, "agent_board.create_thread", () => client.createThread({
+        p_created_by_agent_id: options.createdByAgentId,
+        p_subject: options.subject,
+        p_thread_type: options.threadType,
+        p_metadata: options.metadata,
+    })));
+    program
+        .command("post-message")
+        .requiredOption("--thread-id <threadId>")
+        .option("--author-agent-id <agentId>")
+        .requiredOption("--body <body>")
+        .option("--message-type <messageType>")
+        .option("--task-id <taskId>")
+        .addOption(jsonOption("--metadata <json>", "message metadata"))
+        .action((options) => runHandler(io, "agent_board.post_message", () => client.postMessage({
+        p_thread_id: options.threadId,
+        p_author_agent_id: options.authorAgentId,
+        p_body: options.body,
+        p_message_type: options.messageType,
+        p_task_id: options.taskId,
+        p_metadata: options.metadata,
+    })));
+    program
+        .command("create-task")
+        .requiredOption("--thread-id <threadId>")
+        .option("--created-by-agent-id <agentId>")
+        .requiredOption("--title <title>")
+        .option("--details <details>")
+        .option("--assigned-agent-id <agentId>")
+        .option("--parent-task-id <taskId>")
+        .option("--priority <priority>")
+        .option("--orchestration-mode <orchestrationMode>")
+        .addOption(jsonOption("--metadata <json>", "task metadata"))
+        .action((options) => runHandler(io, "agent_board.create_task", () => client.createTask({
+        p_thread_id: options.threadId,
+        p_created_by_agent_id: options.createdByAgentId,
+        p_title: options.title,
+        p_details: options.details,
+        p_assigned_agent_id: options.assignedAgentId,
+        p_parent_task_id: options.parentTaskId,
+        p_priority: options.priority,
+        p_orchestration_mode: options.orchestrationMode,
+        p_metadata: options.metadata,
+    })));
+    program
+        .command("append-task-event")
+        .requiredOption("--task-id <taskId>")
+        .option("--actor-agent-id <agentId>")
+        .requiredOption("--event-type <eventType>")
+        .option("--status <status>")
+        .option("--assigned-agent-id <agentId>")
+        .option("--completed-at <completedAt>")
+        .addOption(jsonOption("--payload <json>", "event payload"))
+        .action((options) => runHandler(io, "agent_board.append_task_event", () => client.appendTaskEvent({
+        p_task_id: options.taskId,
+        p_actor_agent_id: options.actorAgentId,
+        p_event_type: options.eventType,
+        p_payload: options.payload,
+        p_status: options.status,
+        p_assigned_agent_id: options.assignedAgentId,
+        p_completed_at: options.completedAt,
+    })));
+    program
+        .command("acquire-claim")
+        .option("--agent-id <agentId>")
+        .requiredOption("--resource-kind <resourceKind>")
+        .requiredOption("--resource-key <resourceKey>")
+        .requiredOption("--lease-expires-at <leaseExpiresAt>")
+        .option("--task-id <taskId>")
+        .option("--thread-id <threadId>")
+        .addOption(jsonOption("--metadata <json>", "claim metadata"))
+        .action((options) => runHandler(io, "agent_board.acquire_claim", () => client.acquireClaim({
+        p_agent_id: options.agentId,
+        p_resource_kind: options.resourceKind,
+        p_resource_key: options.resourceKey,
+        p_lease_expires_at: options.leaseExpiresAt,
+        p_task_id: options.taskId,
+        p_thread_id: options.threadId,
+        p_metadata: options.metadata,
+    })));
+    program
+        .command("renew-claim")
+        .requiredOption("--lease-token <leaseToken>")
+        .requiredOption("--lease-expires-at <leaseExpiresAt>")
+        .action((options) => runHandler(io, "agent_board.renew_claim", () => client.renewClaim({
+        p_lease_token: options.leaseToken,
+        p_lease_expires_at: options.leaseExpiresAt,
+    })));
+    program
+        .command("release-claim")
+        .requiredOption("--lease-token <leaseToken>")
+        .action((options) => runHandler(io, "agent_board.release_claim", () => client.releaseClaim({
+        p_lease_token: options.leaseToken,
+    })));
+    program
+        .command("delegate-task")
+        .requiredOption("--parent-task-id <taskId>")
+        .option("--actor-agent-id <agentId>")
+        .requiredOption("--title <title>")
+        .option("--details <details>")
+        .option("--delegated-to-agent-id <agentId>")
+        .option("--priority <priority>")
+        .option("--note <note>")
+        .addOption(jsonOption("--metadata <json>", "delegation metadata"))
+        .action((options) => runHandler(io, "agent_board.delegate_task", () => client.delegateTask({
+        p_parent_task_id: options.parentTaskId,
+        p_actor_agent_id: options.actorAgentId,
+        p_title: options.title,
+        p_details: options.details,
+        p_delegated_to_agent_id: options.delegatedToAgentId,
+        p_priority: options.priority,
+        p_note: options.note,
+        p_metadata: options.metadata,
+    })));
+    program
+        .command("add-artifact")
+        .option("--created-by-agent-id <agentId>")
+        .requiredOption("--uri <uri>")
+        .option("--artifact-type <artifactType>")
+        .option("--storage-kind <storageKind>")
+        .option("--thread-id <threadId>")
+        .option("--task-id <taskId>")
+        .option("--message-id <messageId>")
+        .option("--task-event-id <taskEventId>")
+        .addOption(jsonOption("--metadata <json>", "artifact metadata"))
+        .action((options) => runHandler(io, "agent_board.add_artifact", () => client.addArtifact({
+        p_created_by_agent_id: options.createdByAgentId,
+        p_uri: options.uri,
+        p_artifact_type: options.artifactType,
+        p_storage_kind: options.storageKind,
+        p_thread_id: options.threadId,
+        p_task_id: options.taskId,
+        p_message_id: options.messageId,
+        p_task_event_id: options.taskEventId,
+        p_metadata: options.metadata,
+    })));
+    program
+        .command("raise-conflict")
+        .requiredOption("--thread-id <threadId>")
+        .option("--raised-by-agent-id <agentId>")
+        .requiredOption("--summary <summary>")
+        .option("--conflict-type <conflictType>")
+        .option("--severity <severity>")
+        .option("--task-id <taskId>")
+        .addOption(jsonOption("--details <json>", "conflict details"))
+        .action((options) => runHandler(io, "agent_board.raise_conflict", () => client.raiseConflict({
+        p_thread_id: options.threadId,
+        p_raised_by_agent_id: options.raisedByAgentId,
+        p_summary: options.summary,
+        p_conflict_type: options.conflictType,
+        p_severity: options.severity,
+        p_task_id: options.taskId,
+        p_details: options.details,
+    })));
+    program
+        .command("resolve-conflict")
+        .requiredOption("--conflict-id <conflictId>")
+        .option("--resolved-by-agent-id <agentId>")
+        .option("--task-id <taskId>")
+        .addOption(jsonOption("--details <json>", "resolution details"))
+        .action((options) => runHandler(io, "agent_board.resolve_conflict", () => client.resolveConflict({
+        p_conflict_id: options.conflictId,
+        p_resolved_by_agent_id: options.resolvedByAgentId,
+        p_task_id: options.taskId,
+        p_details: options.details,
+    })));
+    program
+        .command("raise-escalation")
+        .requiredOption("--thread-id <threadId>")
+        .option("--raised-by-agent-id <agentId>")
+        .requiredOption("--summary <summary>")
+        .option("--escalation-type <escalationType>")
+        .option("--severity <severity>")
+        .option("--task-id <taskId>")
+        .option("--assigned-agent-id <agentId>")
+        .addOption(jsonOption("--details <json>", "escalation details"))
+        .action((options) => runHandler(io, "agent_board.raise_escalation", () => client.raiseEscalation({
+        p_thread_id: options.threadId,
+        p_raised_by_agent_id: options.raisedByAgentId,
+        p_summary: options.summary,
+        p_escalation_type: options.escalationType,
+        p_severity: options.severity,
+        p_task_id: options.taskId,
+        p_assigned_agent_id: options.assignedAgentId,
+        p_details: options.details,
+    })));
+    program
+        .command("resolve-escalation")
+        .requiredOption("--escalation-id <escalationId>")
+        .option("--resolved-by-agent-id <agentId>")
+        .option("--task-id <taskId>")
+        .addOption(jsonOption("--details <json>", "resolution details"))
+        .action((options) => runHandler(io, "agent_board.resolve_escalation", () => client.resolveEscalation({
+        p_escalation_id: options.escalationId,
+        p_resolved_by_agent_id: options.resolvedByAgentId,
+        p_task_id: options.taskId,
+        p_details: options.details,
+    })));
+    program
+        .command("mark-read")
+        .requiredOption("--thread-id <threadId>")
+        .option("--agent-id <agentId>")
+        .addOption(numberOption("--last-read-message-sequence <sequence>", "canonical thread cursor"))
+        .action((options) => runHandler(io, "agent_board.mark_read", () => client.markRead({
+        p_thread_id: options.threadId,
+        p_agent_id: options.agentId,
+        p_last_read_message_sequence: options.lastReadMessageSequence,
+    })));
+    program
+        .command("send-direct")
+        .requiredOption("--thread-id <threadId>")
+        .option("--author-agent-id <agentId>")
+        .requiredOption("--recipient-agent-id <agentId>")
+        .requiredOption("--subject <subject>")
+        .requiredOption("--body <body>")
+        .option("--message-type <messageType>")
+        .option("--priority <priority>")
+        .option("--idempotency-key <idempotencyKey>")
+        .addOption(jsonOption("--metadata <json>", "direct message metadata"))
+        .action((options) => runHandler(io, "agent_board.send_direct_message", () => client.sendDirectMessage({
+        p_thread_id: options.threadId,
+        p_author_agent_id: options.authorAgentId,
+        p_recipient_agent_id: options.recipientAgentId,
+        p_subject: options.subject,
+        p_body: options.body,
+        p_message_type: options.messageType,
+        p_priority: options.priority,
+        p_idempotency_key: options.idempotencyKey,
+        p_metadata: options.metadata,
+    })));
+    program
+        .command("send-multicast")
+        .requiredOption("--thread-id <threadId>")
+        .option("--author-agent-id <agentId>")
+        .requiredOption("--recipient-agent-ids <recipientAgentIds>")
+        .requiredOption("--subject <subject>")
+        .requiredOption("--body <body>")
+        .option("--message-type <messageType>")
+        .option("--priority <priority>")
+        .option("--idempotency-key <idempotencyKey>")
+        .addOption(jsonOption("--metadata <json>", "multicast message metadata"))
+        .action((options) => runHandler(io, "agent_board.send_multicast_message", () => client.sendMulticastMessage({
+        p_thread_id: options.threadId,
+        p_author_agent_id: options.authorAgentId,
+        p_recipient_agent_ids: String(options.recipientAgentIds)
+            .split(",")
+            .map((value) => value.trim())
+            .filter(Boolean),
+        p_subject: options.subject,
+        p_body: options.body,
+        p_message_type: options.messageType,
+        p_priority: options.priority,
+        p_idempotency_key: options.idempotencyKey,
+        p_metadata: options.metadata,
+    })));
+    program
+        .command("post-board-message")
+        .requiredOption("--thread-id <threadId>")
+        .option("--author-agent-id <agentId>")
+        .requiredOption("--board-id <boardId>")
+        .requiredOption("--subject <subject>")
+        .requiredOption("--body <body>")
+        .option("--message-type <messageType>")
+        .option("--priority <priority>")
+        .option("--idempotency-key <idempotencyKey>")
+        .addOption(jsonOption("--metadata <json>", "board post metadata"))
+        .action((options) => runHandler(io, "agent_board.post_board_message", () => client.postBoardMessage({
+        p_thread_id: options.threadId,
+        p_author_agent_id: options.authorAgentId,
+        p_board_id: options.boardId,
+        p_subject: options.subject,
+        p_body: options.body,
+        p_message_type: options.messageType,
+        p_priority: options.priority,
+        p_idempotency_key: options.idempotencyKey,
+        p_metadata: options.metadata,
+    })));
+    program
+        .command("create-tasking-delivery")
+        .requiredOption("--thread-id <threadId>")
+        .option("--created-by-agent-id <agentId>")
+        .requiredOption("--title <title>")
+        .option("--details <details>")
+        .option("--recipient-agent-ids <recipientAgentIds>")
+        .option("--board-id <boardId>")
+        .option("--priority <priority>")
+        .option("--orchestration-mode <orchestrationMode>")
+        .option("--idempotency-key <idempotencyKey>")
+        .addOption(jsonOption("--metadata <json>", "tasking metadata"))
+        .action((options) => runHandler(io, "agent_board.create_tasking_delivery", () => client.createTaskingDelivery({
+        p_thread_id: options.threadId,
+        p_created_by_agent_id: options.createdByAgentId,
+        p_title: options.title,
+        p_details: options.details,
+        p_recipient_agent_ids: options.recipientAgentIds
+            ? String(options.recipientAgentIds)
+                .split(",")
+                .map((value) => value.trim())
+                .filter(Boolean)
+            : undefined,
+        p_board_id: options.boardId,
+        p_priority: options.priority,
+        p_orchestration_mode: options.orchestrationMode,
+        p_idempotency_key: options.idempotencyKey,
+        p_metadata: options.metadata,
+    })));
+    program
+        .command("create-board")
+        .option("--created-by-agent-id <agentId>")
+        .requiredOption("--slug <slug>")
+        .requiredOption("--name <name>")
+        .option("--description <description>")
+        .option("--visibility <visibility>")
+        .addOption(jsonOption("--metadata <json>", "board metadata"))
+        .action((options) => runHandler(io, "agent_board.create_board", () => client.createBoard({
+        p_created_by_agent_id: options.createdByAgentId,
+        p_slug: options.slug,
+        p_name: options.name,
+        p_description: options.description,
+        p_visibility: options.visibility,
+        p_metadata: options.metadata,
+    })));
+    program
+        .command("join-board")
+        .requiredOption("--board-id <boardId>")
+        .option("--agent-id <agentId>")
+        .option("--membership-state <membershipState>")
+        .option("--created-by-agent-id <createdByAgentId>")
+        .addOption(jsonOption("--metadata <json>", "membership metadata"))
+        .action((options) => runHandler(io, "agent_board.join_board", () => client.joinBoard({
+        p_board_id: options.boardId,
+        p_agent_id: options.agentId,
+        p_membership_state: options.membershipState,
+        p_created_by_agent_id: options.createdByAgentId,
+        p_metadata: options.metadata,
+    })));
+    program
+        .command("leave-board")
+        .requiredOption("--board-id <boardId>")
+        .option("--agent-id <agentId>")
+        .addOption(jsonOption("--metadata <json>", "membership metadata"))
+        .action((options) => runHandler(io, "agent_board.leave_board", () => client.leaveBoard({
+        p_board_id: options.boardId,
+        p_agent_id: options.agentId,
+        p_metadata: options.metadata,
+    })));
+    program
+        .command("update-board-membership")
+        .requiredOption("--board-id <boardId>")
+        .option("--agent-id <agentId>")
+        .requiredOption("--membership-state <membershipState>")
+        .addOption(jsonOption("--metadata <json>", "membership metadata"))
+        .action((options) => runHandler(io, "agent_board.update_board_membership", () => client.updateBoardMembership({
+        p_board_id: options.boardId,
+        p_agent_id: options.agentId,
+        p_membership_state: options.membershipState,
+        p_metadata: options.metadata,
+    })));
+    program
+        .command("request-join-board")
+        .requiredOption("--board-id <boardId>")
+        .option("--agent-id <agentId>")
+        .addOption(jsonOption("--metadata <json>", "membership request metadata"))
+        .action((options) => runHandler(io, "agent_board.request_join_board", () => client.requestJoinBoard({
+        p_board_id: options.boardId,
+        p_agent_id: options.agentId,
+        p_metadata: options.metadata,
+    })));
+    program
+        .command("invite-board-member")
+        .requiredOption("--board-id <boardId>")
+        .requiredOption("--agent-id <agentId>")
+        .option("--created-by-agent-id <agentId>")
+        .addOption(jsonOption("--metadata <json>", "membership invite metadata"))
+        .action((options) => runHandler(io, "agent_board.invite_board_member", () => client.inviteBoardMember({
+        p_board_id: options.boardId,
+        p_agent_id: options.agentId,
+        p_created_by_agent_id: options.createdByAgentId,
+        p_metadata: options.metadata,
+    })));
+    program
+        .command("resolve-board-request")
+        .requiredOption("--board-id <boardId>")
+        .requiredOption("--agent-id <agentId>")
+        .requiredOption("--membership-state <membershipState>")
+        .option("--created-by-agent-id <agentId>")
+        .addOption(jsonOption("--metadata <json>", "membership resolution metadata"))
+        .action((options) => runHandler(io, "agent_board.resolve_board_request", () => client.resolveBoardRequest({
+        p_board_id: options.boardId,
+        p_agent_id: options.agentId,
+        p_membership_state: options.membershipState,
+        p_created_by_agent_id: options.createdByAgentId,
+        p_metadata: options.metadata,
+    })));
+    program
+        .command("update-inbox-item-state")
+        .requiredOption("--inbox-item-id <inboxItemId>")
+        .option("--recipient-agent-id <agentId>")
+        .requiredOption("--action-state <actionState>")
+        .addOption(jsonOption("--metadata <json>", "inbox transition metadata"))
+        .action((options) => runHandler(io, "agent_board.update_inbox_item_state", () => client.updateInboxItemState({
+        p_inbox_item_id: options.inboxItemId,
+        p_recipient_agent_id: options.recipientAgentId,
+        p_action_state: options.actionState,
+        p_metadata: options.metadata,
+    })));
+    program
+        .command("register-callback-endpoint")
+        .option("--owner-agent-id <agentId>")
+        .requiredOption("--endpoint-url <endpointUrl>")
+        .addOption(jsonOption("--metadata <json>", "endpoint metadata"))
+        .action((options) => runHandler(io, "agent_board.register_callback_endpoint", () => client.registerCallbackEndpoint({
+        p_owner_agent_id: options.ownerAgentId,
+        p_endpoint_url: options.endpointUrl,
+        p_metadata: options.metadata,
+    })));
+    program
+        .command("verify-callback-endpoint")
+        .requiredOption("--endpoint-id <endpointId>")
+        .option("--owner-agent-id <agentId>")
+        .addOption(jsonOption("--metadata <json>", "verification metadata"))
+        .action((options) => runHandler(io, "agent_board.verify_callback_endpoint", () => client.verifyCallbackEndpoint({
+        p_endpoint_id: options.endpointId,
+        p_owner_agent_id: options.ownerAgentId,
+        p_metadata: options.metadata,
+    })));
+    program
+        .command("disable-callback-endpoint")
+        .requiredOption("--endpoint-id <endpointId>")
+        .option("--owner-agent-id <agentId>")
+        .option("--disabled-reason <disabledReason>")
+        .addOption(jsonOption("--metadata <json>", "disablement metadata"))
+        .action((options) => runHandler(io, "agent_board.disable_callback_endpoint", () => client.disableCallbackEndpoint({
+        p_endpoint_id: options.endpointId,
+        p_owner_agent_id: options.ownerAgentId,
+        p_disabled_reason: options.disabledReason,
+        p_metadata: options.metadata,
+    })));
+    program
+        .command("rotate-callback-signing-key")
+        .requiredOption("--endpoint-id <endpointId>")
+        .option("--owner-agent-id <agentId>")
+        .addOption(jsonOption("--metadata <json>", "rotation metadata"))
+        .action((options) => runHandler(io, "agent_board.rotate_callback_signing_key", () => client.rotateCallbackSigningKey({
+        p_endpoint_id: options.endpointId,
+        p_owner_agent_id: options.ownerAgentId,
+        p_metadata: options.metadata,
+    })));
+    program
+        .command("delete-callback-endpoint")
+        .requiredOption("--endpoint-id <endpointId>")
+        .option("--owner-agent-id <agentId>")
+        .action((options) => runHandler(io, "agent_board.delete_callback_endpoint", () => client.deleteCallbackEndpoint({
+        p_endpoint_id: options.endpointId,
+        p_owner_agent_id: options.ownerAgentId,
+    })));
+    program
+        .command("subscribe-callback-endpoint")
+        .requiredOption("--endpoint-id <endpointId>")
+        .option("--agent-id <agentId>")
+        .requiredOption("--subscription-scope <subscriptionScope>")
+        .requiredOption("--event-category <eventCategory>")
+        .option("--board-id <boardId>")
+        .addOption(jsonOption("--metadata <json>", "subscription metadata"))
+        .action((options) => runHandler(io, "agent_board.subscribe_callback_endpoint", () => client.subscribeCallbackEndpoint({
+        p_endpoint_id: options.endpointId,
+        p_agent_id: options.agentId,
+        p_subscription_scope: options.subscriptionScope,
+        p_event_category: options.eventCategory,
+        p_board_id: options.boardId,
+        p_metadata: options.metadata,
+    })));
+    program
+        .command("unsubscribe-callback-endpoint")
+        .requiredOption("--endpoint-id <endpointId>")
+        .option("--agent-id <agentId>")
+        .requiredOption("--subscription-scope <subscriptionScope>")
+        .requiredOption("--event-category <eventCategory>")
+        .option("--board-id <boardId>")
+        .addOption(jsonOption("--metadata <json>", "subscription metadata"))
+        .action((options) => runHandler(io, "agent_board.unsubscribe_callback_endpoint", () => client.unsubscribeCallbackEndpoint({
+        p_endpoint_id: options.endpointId,
+        p_agent_id: options.agentId,
+        p_subscription_scope: options.subscriptionScope,
+        p_event_category: options.eventCategory,
+        p_board_id: options.boardId,
+        p_metadata: options.metadata,
+    })));
+}
+function addReadCommands(program, client, io) {
+    program
+        .command("whoami")
+        .option("--agent-id <agentId>")
+        .option("--handle <handle>")
+        .action((options) => runHandler(io, "agent_board.whoami", () => client.whoami({
+        agentId: options.agentId,
+        handle: options.handle,
+    })));
+    program
+        .command("notification-status")
+        .option("--endpoint-id <endpointId>")
+        .option("--agent-id <agentId>")
+        .option("--board-id <boardId>")
+        .option("--subscription-scope <subscriptionScope>")
+        .option("--event-category <eventCategory>")
+        .addOption(numberOption("--limit <limit>", "row limit"))
+        .action((options) => runHandler(io, "agent_board.v_callback_delivery_health", () => client.notificationStatus({
+        endpointId: options.endpointId,
+        agentId: options.agentId,
+        boardId: options.boardId,
+        subscriptionScope: options.subscriptionScope,
+        eventCategory: options.eventCategory,
+        limit: options.limit,
+    })));
+    program
+        .command("notification-ack")
+        .requiredOption("--inbox-item-id <inboxItemId>")
+        .option("--recipient-agent-id <agentId>")
+        .addOption(jsonOption("--metadata <json>", "ack metadata"))
+        .action((options) => runHandler(io, "agent_board.notification_ack", () => client.notificationAck({
+        inboxItemId: options.inboxItemId,
+        recipientAgentId: options.recipientAgentId,
+        metadata: options.metadata,
+    })));
+    const endpoint = program.command("endpoint").description("notification endpoint commands");
+    endpoint
+        .command("register")
+        .option("--owner-agent-id <agentId>")
+        .requiredOption("--endpoint-url <endpointUrl>")
+        .addOption(jsonOption("--metadata <json>", "endpoint metadata"))
+        .action((options) => runHandler(io, "agent_board.register_callback_endpoint", () => client.registerNotificationEndpoint({
+        p_owner_agent_id: options.ownerAgentId,
+        p_endpoint_url: options.endpointUrl,
+        p_metadata: options.metadata,
+    })));
+    endpoint
+        .command("verify")
+        .requiredOption("--endpoint-id <endpointId>")
+        .option("--owner-agent-id <agentId>")
+        .addOption(jsonOption("--metadata <json>", "verification metadata"))
+        .action((options) => runHandler(io, "agent_board.verify_callback_endpoint", () => client.verifyNotificationEndpoint({
+        p_endpoint_id: options.endpointId,
+        p_owner_agent_id: options.ownerAgentId,
+        p_metadata: options.metadata,
+    })));
+    endpoint
+        .command("status")
+        .option("--endpoint-id <endpointId>")
+        .option("--owner-agent-id <agentId>")
+        .addOption(numberOption("--limit <limit>", "row limit"))
+        .action((options) => runHandler(io, "agent_board.v_callback_endpoint_status", () => client.callbackEndpointStatus({
+        endpointId: options.endpointId,
+        ownerAgentId: options.ownerAgentId,
+        limit: options.limit,
+    })));
+    const subscription = program.command("subscription").description("notification subscription commands");
+    subscription
+        .command("add")
+        .requiredOption("--endpoint-id <endpointId>")
+        .option("--agent-id <agentId>")
+        .requiredOption("--subscription-scope <subscriptionScope>")
+        .requiredOption("--event-category <eventCategory>")
+        .option("--board-id <boardId>")
+        .addOption(jsonOption("--metadata <json>", "subscription metadata"))
+        .action((options) => runHandler(io, "agent_board.subscribe_callback_endpoint", () => client.subscribeNotificationEndpoint({
+        p_endpoint_id: options.endpointId,
+        p_agent_id: options.agentId,
+        p_subscription_scope: options.subscriptionScope,
+        p_event_category: options.eventCategory,
+        p_board_id: options.boardId,
+        p_metadata: options.metadata,
+    })));
+    subscription
+        .command("remove")
+        .requiredOption("--endpoint-id <endpointId>")
+        .option("--agent-id <agentId>")
+        .requiredOption("--subscription-scope <subscriptionScope>")
+        .requiredOption("--event-category <eventCategory>")
+        .option("--board-id <boardId>")
+        .addOption(jsonOption("--metadata <json>", "subscription metadata"))
+        .action((options) => runHandler(io, "agent_board.unsubscribe_callback_endpoint", () => client.unsubscribeNotificationEndpoint({
+        p_endpoint_id: options.endpointId,
+        p_agent_id: options.agentId,
+        p_subscription_scope: options.subscriptionScope,
+        p_event_category: options.eventCategory,
+        p_board_id: options.boardId,
+        p_metadata: options.metadata,
+    })));
+    subscription
+        .command("list")
+        .option("--endpoint-id <endpointId>")
+        .option("--agent-id <agentId>")
+        .option("--board-id <boardId>")
+        .option("--subscription-scope <subscriptionScope>")
+        .option("--event-category <eventCategory>")
+        .option("--subscription-status <subscriptionStatus>")
+        .addOption(numberOption("--limit <limit>", "row limit"))
+        .action((options) => runHandler(io, "agent_board.v_callback_subscriptions", () => client.callbackSubscriptions({
+        endpointId: options.endpointId,
+        agentId: options.agentId,
+        boardId: options.boardId,
+        subscriptionScope: options.subscriptionScope,
+        eventCategory: options.eventCategory,
+        subscriptionStatus: options.subscriptionStatus,
+        limit: options.limit,
+    })));
+    const watch = program.command("watch").description("bounded JSONL watch descriptors");
+    watch
+        .command("inbox")
+        .option("--recipient-agent-id <agentId>")
+        .option("--board-id <boardId>")
+        .option("--action-state <actionState>")
+        .option("--after-cursor <afterCursor>")
+        .addOption(numberOption("--limit <limit>", "row limit"))
+        .option("--jsonl")
+        .action((options) => runJsonlHandler(io, "agent_board.watch_inbox", () => client.watchInbox({
+        recipientAgentId: options.recipientAgentId,
+        boardId: options.boardId,
+        actionState: options.actionState,
+        afterCursor: options.afterCursor,
+        limit: options.limit,
+        jsonl: Boolean(options.jsonl),
+    })));
+    watch
+        .command("supervision")
+        .option("--assigned-agent-id <agentId>")
+        .option("--after-cursor <afterCursor>")
+        .addOption(numberOption("--limit <limit>", "row limit"))
+        .option("--jsonl")
+        .action((options) => runJsonlHandler(io, "agent_board.watch_supervision", () => client.watchSupervision({
+        assignedAgentId: options.assignedAgentId,
+        afterCursor: options.afterCursor,
+        limit: options.limit,
+        jsonl: Boolean(options.jsonl),
+    })));
+    const worker = program.command("worker").description("notification worker commands");
+    worker
+        .command("notifications")
+        .option("--endpoint-id <endpointId>")
+        .option("--agent-id <agentId>")
+        .addOption(numberOption("--limit <limit>", "row limit"))
+        .action((options) => runHandler(io, "agent_board.worker_notifications", () => client.workerNotifications({
+        endpointId: options.endpointId,
+        agentId: options.agentId,
+        limit: options.limit,
+    })));
+    worker
+        .command("claim-notifications")
+        .addOption(numberOption("--limit <limit>", "claim limit"))
+        .option("--lease-expires-at <leaseExpiresAt>")
+        .action((options) => runHandler(io, "agent_board.claim_callback_outbox_events", () => client.claimNotificationOutboxEvents({
+        p_limit: options.limit,
+        p_lease_expires_at: options.leaseExpiresAt,
+    })));
+    const supervision = program.command("supervision").description("human supervision commands");
+    supervision
+        .command("feed")
+        .option("--assigned-agent-id <agentId>")
+        .option("--thread-id <threadId>")
+        .option("--task-id <taskId>")
+        .addOption(numberOption("--limit <limit>", "row limit"))
+        .action((options) => runHandler(io, "agent_board.v_open_escalations", () => client.supervisionFeed({
+        assignedAgentId: options.assignedAgentId,
+        threadId: options.threadId,
+        taskId: options.taskId,
+        limit: options.limit,
+    })));
+    supervision
+        .command("scopes")
+        .option("--resource-kind <resourceKind>")
+        .option("--resource-key <resourceKey>")
+        .option("--agent-id <agentId>")
+        .option("--task-id <taskId>")
+        .option("--thread-id <threadId>")
+        .addOption(numberOption("--limit <limit>", "row limit"))
+        .action((options) => runHandler(io, "agent_board.v_active_claims", () => client.supervisionScopes({
+        resourceKind: options.resourceKind,
+        resourceKey: options.resourceKey,
+        agentId: options.agentId,
+        taskId: options.taskId,
+        threadId: options.threadId,
+        limit: options.limit,
+    })));
+    supervision
+        .command("approve")
+        .requiredOption("--task-id <taskId>")
+        .option("--actor-agent-id <agentId>")
+        .option("--summary <summary>")
+        .addOption(jsonOption("--details <json>", "approval details"))
+        .action((options) => runHandler(io, "agent_board.supervision_approval", () => client.approveIntervention({
+        taskId: options.taskId,
+        actorAgentId: options.actorAgentId,
+        summary: options.summary,
+        details: options.details,
+    })));
+    supervision
+        .command("reject")
+        .requiredOption("--task-id <taskId>")
+        .option("--actor-agent-id <agentId>")
+        .option("--summary <summary>")
+        .addOption(jsonOption("--details <json>", "rejection details"))
+        .action((options) => runHandler(io, "agent_board.supervision_approval", () => client.rejectIntervention({
+        taskId: options.taskId,
+        actorAgentId: options.actorAgentId,
+        summary: options.summary,
+        details: options.details,
+    })));
+    program
+        .command("pipeline-task-inbox")
+        .option("--assigned-agent-id <agentId>")
+        .option("--delivery-mode <deliveryMode>")
+        .option("--action-state <actionState>")
+        .addOption(numberOption("--limit <limit>", "row limit"))
+        .action((options) => runHandler(io, "agent_board.pipeline_task_inbox", () => client.pipelineTaskInbox({
+        assignedAgentId: options.assignedAgentId,
+        deliveryMode: options.deliveryMode,
+        actionState: options.actionState,
+        limit: options.limit,
+    })));
+    program
+        .command("pipeline-task-update")
+        .requiredOption("--task-id <taskId>")
+        .requiredOption("--update-kind <updateKind>")
+        .option("--thread-id <threadId>")
+        .option("--actor-agent-id <agentId>")
+        .option("--assigned-agent-id <agentId>")
+        .option("--status <status>")
+        .option("--summary <summary>")
+        .option("--escalation-id <escalationId>")
+        .option("--completed-at <completedAt>")
+        .addOption(jsonOption("--details <json>", "pipeline update details"))
+        .action((options) => runHandler(io, "agent_board.pipeline_task_update", () => client.updatePipelineTask({
+        taskId: options.taskId,
+        updateKind: options.updateKind,
+        threadId: options.threadId,
+        actorAgentId: options.actorAgentId,
+        assignedAgentId: options.assignedAgentId,
+        status: options.status,
+        summary: options.summary,
+        escalationId: options.escalationId,
+        completedAt: options.completedAt,
+        details: options.details,
+    })));
+    program
+        .command("pipeline-subscribe-callback")
+        .option("--endpoint-id <endpointId>")
+        .option("--endpoint-url <endpointUrl>")
+        .option("--agent-id <agentId>")
+        .requiredOption("--subscription-scope <subscriptionScope>")
+        .requiredOption("--event-category <eventCategory>")
+        .option("--board-id <boardId>")
+        .option("--verify-endpoint <verifyEndpoint>")
+        .addOption(jsonOption("--metadata <json>", "callback metadata"))
+        .action((options) => runHandler(io, "agent_board.pipeline_subscribe_callback", () => client.subscribePipelineCallback({
+        endpointId: options.endpointId,
+        endpointUrl: options.endpointUrl,
+        agentId: options.agentId,
+        subscriptionScope: options.subscriptionScope,
+        eventCategory: options.eventCategory,
+        boardId: options.boardId,
+        verifyEndpoint: options.verifyEndpoint === undefined ? undefined : options.verifyEndpoint !== "false",
+        metadata: options.metadata,
+    })));
+    program
+        .command("pipeline-refresh-context")
+        .requiredOption("--target <json>")
+        .action((options) => runHandler(io, "agent_board.pipeline_refresh_context", () => client.refreshPipelineContext(parseJson(options.target) ?? {})));
+    program
+        .command("thread-feed")
+        .requiredOption("--thread-id <threadId>")
+        .addOption(numberOption("--after-sequence <sequence>", "resume after this message sequence"))
+        .addOption(numberOption("--limit <limit>", "row limit"))
+        .action((options) => runHandler(io, "agent_board.v_thread_feed", () => client.threadFeed({
+        threadId: options.threadId,
+        afterSequence: options.afterSequence,
+        limit: options.limit,
+    })));
+    program
+        .command("task-tree")
+        .option("--root-task-id <taskId>")
+        .option("--thread-id <threadId>")
+        .option("--task-id <taskId>")
+        .addOption(numberOption("--limit <limit>", "row limit"))
+        .action((options) => runHandler(io, "agent_board.v_task_tree", () => client.taskTree({
+        rootTaskId: options.rootTaskId,
+        threadId: options.threadId,
+        taskId: options.taskId,
+        limit: options.limit,
+    })));
+    program
+        .command("active-claims")
+        .option("--resource-kind <resourceKind>")
+        .option("--resource-key <resourceKey>")
+        .option("--agent-id <agentId>")
+        .option("--task-id <taskId>")
+        .option("--thread-id <threadId>")
+        .addOption(numberOption("--limit <limit>", "row limit"))
+        .action((options) => runHandler(io, "agent_board.v_active_claims", () => client.activeClaims({
+        resourceKind: options.resourceKind,
+        resourceKey: options.resourceKey,
+        agentId: options.agentId,
+        taskId: options.taskId,
+        threadId: options.threadId,
+        limit: options.limit,
+    })));
+    program
+        .command("open-escalations")
+        .option("--assigned-agent-id <agentId>")
+        .option("--thread-id <threadId>")
+        .option("--task-id <taskId>")
+        .addOption(numberOption("--limit <limit>", "row limit"))
+        .action((options) => runHandler(io, "agent_board.v_open_escalations", () => client.openEscalations({
+        assignedAgentId: options.assignedAgentId,
+        threadId: options.threadId,
+        taskId: options.taskId,
+        limit: options.limit,
+    })));
+    program
+        .command("agent-dashboard")
+        .option("--agent-id <agentId>")
+        .option("--handle <handle>")
+        .addOption(numberOption("--limit <limit>", "row limit"))
+        .action((options) => runHandler(io, "agent_board.v_agent_dashboard", () => client.agentDashboard({
+        agentId: options.agentId,
+        handle: options.handle,
+        limit: options.limit,
+    })));
+    program
+        .command("agent-inbox")
+        .alias("inbox")
+        .option("--recipient-agent-id <agentId>")
+        .option("--board-id <boardId>")
+        .option("--delivery-mode <deliveryMode>")
+        .option("--action-state <actionState>")
+        .addOption(numberOption("--limit <limit>", "row limit"))
+        .action((options) => runHandler(io, "agent_board.v_agent_inbox", () => client.agentInbox({
+        recipientAgentId: options.recipientAgentId,
+        boardId: options.boardId,
+        deliveryMode: options.deliveryMode,
+        actionState: options.actionState,
+        limit: options.limit,
+    })));
+    program
+        .command("agent-inbox-counts")
+        .alias("inbox-counts")
+        .option("--recipient-agent-id <agentId>")
+        .addOption(numberOption("--limit <limit>", "row limit"))
+        .action((options) => runHandler(io, "agent_board.v_agent_inbox_counts", () => client.agentInboxCounts({
+        recipientAgentId: options.recipientAgentId,
+        limit: options.limit,
+    })));
+    program
+        .command("board-directory")
+        .option("--board-id <boardId>")
+        .option("--board-slug <boardSlug>")
+        .option("--visibility <visibility>")
+        .addOption(numberOption("--limit <limit>", "row limit"))
+        .action((options) => runHandler(io, "agent_board.v_board_directory", () => client.boardDirectory({
+        boardId: options.boardId,
+        boardSlug: options.boardSlug,
+        visibility: options.visibility,
+        limit: options.limit,
+    })));
+    program
+        .command("board-memberships")
+        .option("--board-id <boardId>")
+        .option("--agent-id <agentId>")
+        .option("--membership-state <membershipState>")
+        .addOption(numberOption("--limit <limit>", "row limit"))
+        .action((options) => runHandler(io, "agent_board.v_board_memberships", () => client.boardMemberships({
+        boardId: options.boardId,
+        agentId: options.agentId,
+        membershipState: options.membershipState,
+        limit: options.limit,
+    })));
+    program
+        .command("board-feed")
+        .option("--board-id <boardId>")
+        .option("--board-slug <boardSlug>")
+        .option("--after-created-at <afterCreatedAt>")
+        .addOption(numberOption("--limit <limit>", "row limit"))
+        .action((options) => runHandler(io, "agent_board.v_board_feed", () => client.boardFeed({
+        boardId: options.boardId,
+        boardSlug: options.boardSlug,
+        afterCreatedAt: options.afterCreatedAt,
+        limit: options.limit,
+    })));
+    program
+        .command("callback-endpoint-status")
+        .option("--endpoint-id <endpointId>")
+        .option("--owner-agent-id <agentId>")
+        .addOption(numberOption("--limit <limit>", "row limit"))
+        .action((options) => runHandler(io, "agent_board.v_callback_endpoint_status", () => client.callbackEndpointStatus({
+        endpointId: options.endpointId,
+        ownerAgentId: options.ownerAgentId,
+        limit: options.limit,
+    })));
+    program
+        .command("callback-subscriptions")
+        .option("--endpoint-id <endpointId>")
+        .option("--agent-id <agentId>")
+        .option("--board-id <boardId>")
+        .option("--subscription-scope <subscriptionScope>")
+        .option("--event-category <eventCategory>")
+        .option("--subscription-status <subscriptionStatus>")
+        .addOption(numberOption("--limit <limit>", "row limit"))
+        .action((options) => runHandler(io, "agent_board.v_callback_subscriptions", () => client.callbackSubscriptions({
+        endpointId: options.endpointId,
+        agentId: options.agentId,
+        boardId: options.boardId,
+        subscriptionScope: options.subscriptionScope,
+        eventCategory: options.eventCategory,
+        subscriptionStatus: options.subscriptionStatus,
+        limit: options.limit,
+    })));
+    program
+        .command("callback-delivery-health")
+        .option("--endpoint-id <endpointId>")
+        .option("--agent-id <agentId>")
+        .option("--board-id <boardId>")
+        .option("--subscription-scope <subscriptionScope>")
+        .option("--event-category <eventCategory>")
+        .addOption(numberOption("--limit <limit>", "row limit"))
+        .action((options) => runHandler(io, "agent_board.v_callback_delivery_health", () => client.callbackDeliveryHealth({
+        endpointId: options.endpointId,
+        agentId: options.agentId,
+        boardId: options.boardId,
+        subscriptionScope: options.subscriptionScope,
+        eventCategory: options.eventCategory,
+        limit: options.limit,
+    })));
+}
+export function createProgram(client, io) {
+    const program = new Command()
+        .name("agent-board")
+        .description("Thin CLI surface for the agent_board RPC and canonical read contracts")
+        .addHelpText("after", "\nAuth: user-scoped agent sessions are the default. Service-role execution is reserved for callback workers and vetted operational scripts through explicit client configuration, not the normal agent CLI path. Signing configuration is inherited from metadata-safe descriptors; raw private-key arguments are not accepted.\n");
+    program
+        .command("signing-status")
+        .description("Print metadata-safe signing descriptor status; raw private-key arguments are not accepted")
+        .action(() => runHandler(io, "agent_board.signing_status", async () => signingStatusFromEnv()));
+    const runtime = program.command("runtime").description("metadata-safe runtime diagnostics");
+    runtime
+        .command("status")
+        .description("Print runtime discovery status without credential values")
+        .action(() => runHandler(io, "agent_board.runtime_status", () => client.runtimeStatus()));
+    runtime
+        .command("doctor")
+        .description("Validate runtime discovery and direct fallback posture without credential values")
+        .option("--require-runtime")
+        .action((options) => runRuntimeDoctor(io, client, Boolean(options.requireRuntime)));
+    addWriteCommands(program, client, io);
+    addReadCommands(program, client, io);
+    return program;
+}
+export async function runCli(argv, io = {
+    writeStdout: (message) => process.stdout.write(message),
+    writeStderr: (message) => process.stderr.write(message),
+}, client = createAgentBoardClient()) {
+    const program = createProgram(client, io);
+    await program.parseAsync(argv, { from: "user" });
+}