@maiaos/cli 0.1.0-canary.44938d4.manual.1

package/dist/orchestration/client.d.ts

@@ -0,0 +1,59 @@
+import type { OrchestrationDispatchSettleTerminalResult, OrchestrationDispatchShowResult, OrchestrationInboxAckResult, OrchestrationInboxCheckParameters, OrchestrationInboxCheckResult, OrchestrationQuestionCancelResult, OrchestrationQuestionOpenResult, OrchestrationQuestionReplyResult, OrchestrationRunCreateResult, OrchestrationRunListResult, OrchestrationRunShowResult, OrchestrationTaskGraph, OrchestrationTaskListResult, OrchestrationTaskShowResult } from "@maiaos/sdk";
+import { type CliNodeResult } from "../local-node/client.js";
+type MutationInput = {
+    readonly commandId?: string;
+};
+type CreateRunInput = {
+    readonly commandId?: string;
+    readonly graph: OrchestrationTaskGraph;
+    readonly terminalId: string;
+    readonly workspaceId: string;
+};
+export declare const createRun: (input: CreateRunInput) => Promise<CliNodeResult<OrchestrationRunCreateResult>>;
+export declare const listRuns: (input: {
+    readonly afterCursor: string;
+    readonly limit: number;
+    readonly workspaceId: string;
+}) => Promise<CliNodeResult<OrchestrationRunListResult>>;
+export declare const showRun: (runId: string) => Promise<CliNodeResult<OrchestrationRunShowResult>>;
+export declare const listTasks: (input: {
+    readonly afterCursor: string;
+    readonly limit: number;
+    readonly runId: string;
+}) => Promise<CliNodeResult<OrchestrationTaskListResult>>;
+export declare const showDispatch: (runId: string) => Promise<CliNodeResult<OrchestrationDispatchShowResult>>;
+export declare const showTask: (input: {
+    readonly runId: string;
+    readonly taskId: string;
+}) => Promise<CliNodeResult<OrchestrationTaskShowResult>>;
+export declare const checkRunInbox: (input: OrchestrationInboxCheckParameters) => Promise<CliNodeResult<OrchestrationInboxCheckResult>>;
+export declare const acknowledgeRunDelivery: (input: MutationInput & {
+    readonly coordinatorEpoch: 1;
+    readonly deliveryId: string;
+    readonly expectedMailboxRevision: string;
+    readonly owner: OrchestrationInboxCheckParameters["owner"];
+    readonly runId: string;
+}) => Promise<CliNodeResult<OrchestrationInboxAckResult>>;
+type QuestionScopeInput = MutationInput & {
+    readonly coordinatorEpoch: 1;
+    readonly dispatchId: string;
+    readonly expectedDispatchRevision: string;
+    readonly expectedRunRevision: string;
+    readonly runId: string;
+};
+export declare const openRunQuestion: (input: QuestionScopeInput & {
+    readonly body: string;
+    readonly subject: string;
+}) => Promise<CliNodeResult<OrchestrationQuestionOpenResult>>;
+export declare const replyRunQuestion: (input: QuestionScopeInput & {
+    readonly answer: string;
+    readonly expectedQuestionRevision: string;
+    readonly questionId: string;
+}) => Promise<CliNodeResult<OrchestrationQuestionReplyResult>>;
+export declare const cancelRunQuestion: (input: QuestionScopeInput & {
+    readonly expectedQuestionRevision: string;
+    readonly questionId: string;
+}) => Promise<CliNodeResult<OrchestrationQuestionCancelResult>>;
+export declare const settleRunDispatchTerminal: (input: QuestionScopeInput) => Promise<CliNodeResult<OrchestrationDispatchSettleTerminalResult>>;
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/orchestration/client.js

@@ -0,0 +1,66 @@
+import { inspectOrchestrationRunCreateAdmission, orchestrationDispatchSettleTerminalParametersSchema, orchestrationDispatchShowParametersSchema, orchestrationInboxAckParametersSchema, orchestrationInboxCheckParametersSchema, orchestrationQuestionCancelParametersSchema, orchestrationQuestionOpenParametersSchema, orchestrationQuestionReplyParametersSchema, orchestrationRunCreateParametersSchema, orchestrationRunListParametersSchema, orchestrationRunShowParametersSchema, orchestrationTaskListParametersSchema, orchestrationTaskShowParametersSchema, } from "@maiaos/sdk";
+import { invalidNodeInput, newCliIdentifier, runNodeClientOperation, runValidatedNodeOperation, } from "../local-node/client.js";
+const admittedRunCreateParameters = (input, commandId) => {
+    const parameters = orchestrationRunCreateParametersSchema.safeParse({
+        commandId,
+        expectedRevision: "0",
+        graph: input.graph,
+        terminalId: input.terminalId,
+        workspaceId: input.workspaceId,
+    });
+    if (!parameters.success)
+        return;
+    try {
+        inspectOrchestrationRunCreateAdmission(parameters.data);
+    }
+    catch {
+        return;
+    }
+    return parameters.data;
+};
+export const createRun = (input) => {
+    const commandId = input.commandId ?? newCliIdentifier("command");
+    const parameters = admittedRunCreateParameters(input, commandId);
+    if (parameters === undefined)
+        return invalidNodeInput();
+    return runNodeClientOperation((client, options) => client.createOrchestrationRun(parameters, options), { commandId });
+};
+export const listRuns = (input) => {
+    return runValidatedNodeOperation(input, orchestrationRunListParametersSchema, (client, parameters, options) => client.listOrchestrationRuns(parameters, options));
+};
+export const showRun = (runId) => {
+    return runValidatedNodeOperation({ runId }, orchestrationRunShowParametersSchema, (client, parameters, options) => client.showOrchestrationRun(parameters, options));
+};
+export const listTasks = (input) => {
+    return runValidatedNodeOperation(input, orchestrationTaskListParametersSchema, (client, parameters, options) => client.listOrchestrationTasks(parameters, options));
+};
+export const showDispatch = (runId) => {
+    return runValidatedNodeOperation({ runId }, orchestrationDispatchShowParametersSchema, (client, parameters, options) => client.showOrchestrationDispatch(parameters, options));
+};
+export const showTask = (input) => {
+    return runValidatedNodeOperation(input, orchestrationTaskShowParametersSchema, (client, parameters, options) => client.showOrchestrationTask(parameters, options));
+};
+export const checkRunInbox = (input) => {
+    return runValidatedNodeOperation(input, orchestrationInboxCheckParametersSchema, (client, parameters, options) => client.checkOrchestrationInbox(parameters, options));
+};
+export const acknowledgeRunDelivery = (input) => {
+    const commandId = input.commandId ?? newCliIdentifier("command");
+    return runValidatedNodeOperation({ ...input, commandId }, orchestrationInboxAckParametersSchema, (client, parameters, options) => client.acknowledgeOrchestrationDelivery(parameters, options), { commandId });
+};
+export const openRunQuestion = (input) => {
+    const commandId = input.commandId ?? newCliIdentifier("command");
+    return runValidatedNodeOperation({ ...input, commandId }, orchestrationQuestionOpenParametersSchema, (client, parameters, options) => client.openOrchestrationQuestion(parameters, options), { commandId });
+};
+export const replyRunQuestion = (input) => {
+    const commandId = input.commandId ?? newCliIdentifier("command");
+    return runValidatedNodeOperation({ ...input, commandId }, orchestrationQuestionReplyParametersSchema, (client, parameters, options) => client.replyOrchestrationQuestion(parameters, options), { commandId });
+};
+export const cancelRunQuestion = (input) => {
+    const commandId = input.commandId ?? newCliIdentifier("command");
+    return runValidatedNodeOperation({ ...input, commandId }, orchestrationQuestionCancelParametersSchema, (client, parameters, options) => client.cancelOrchestrationQuestion(parameters, options), { commandId });
+};
+export const settleRunDispatchTerminal = (input) => {
+    const commandId = input.commandId ?? newCliIdentifier("command");
+    return runValidatedNodeOperation({ ...input, commandId }, orchestrationDispatchSettleTerminalParametersSchema, (client, parameters, options) => client.settleOrchestrationDispatchTerminal(parameters, options), { commandId });
+};
+//# sourceMappingURL=client.js.map

package/dist/orchestration/commands.d.ts

@@ -0,0 +1,3 @@
+import type { CommandContext } from "../command-line/context.js";
+export declare const runOrchestrationCommand: (tokens: readonly string[], context: CommandContext) => Promise<number>;
+//# sourceMappingURL=commands.d.ts.map

package/dist/orchestration/commands.js

@@ -0,0 +1,336 @@
+import { DEFAULT_ORCHESTRATION_TASK_LIST_PAGE_SIZE, orchestrationQuestionOpenParametersSchema, orchestrationQuestionReplyParametersSchema, orchestrationTaskGraphSchema, } from "@maiaos/sdk";
+import { CliArgumentError, parseOptions, readCursor, readExpectedRevision, readPageSize, requirePositionals, } from "../command-line/arguments.js";
+import { writeDispatchSettleResult, writeDispatchShowResult, writeInboxAckResult, writeInboxCheckResult, writeQuestionCancelResult, writeQuestionOpenResult, writeQuestionReplyResult, writeRunCreateResult, writeRunListResult, writeRunShowResult, writeTaskListResult, writeTaskShowResult, } from "../command-line/output.js";
+const requireOption = (parsed, name) => {
+    const value = parsed.options.get(name);
+    if (value === undefined) {
+        throw new CliArgumentError(`Option '${name}' is required.`);
+    }
+    return value;
+};
+const coordinatorEpoch = (parsed) => {
+    if (requireOption(parsed, "--coordinator-epoch") !== "1") {
+        throw new CliArgumentError("Option '--coordinator-epoch' must be exactly 1 for local v1.");
+    }
+    return 1;
+};
+const revision = (parsed, name) => readExpectedRevision(requireOption(parsed, name));
+const mutationCommandId = (parsed) => {
+    const commandId = parsed.options.get("--command-id");
+    return commandId === undefined ? {} : { commandId };
+};
+const questionScope = (parsed, runId, dispatchId) => ({
+    coordinatorEpoch: coordinatorEpoch(parsed),
+    dispatchId,
+    expectedDispatchRevision: revision(parsed, "--expected-dispatch-revision"),
+    expectedRunRevision: revision(parsed, "--expected-run-revision"),
+    runId,
+    ...mutationCommandId(parsed),
+});
+const parseRunCreateScope = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--command-id"]), new Set(["--graph-stdin"]));
+    requirePositionals(parsed.positionals, 2, "maia run create <workspace-id> <terminal-id> --graph-stdin");
+    if (!parsed.flags.has("--graph-stdin")) {
+        throw new CliArgumentError("Option '--graph-stdin' is required.");
+    }
+    const [workspaceId, terminalId] = parsed.positionals;
+    if (workspaceId === undefined || terminalId === undefined) {
+        throw new CliArgumentError("The Run scope is incomplete.");
+    }
+    return { parsed, terminalId, workspaceId };
+};
+const readTaskGraph = async (context) => {
+    if (context.io.stdin === undefined) {
+        throw new CliArgumentError("Standard input is unavailable.");
+    }
+    const graphText = await context.io.stdin({
+        label: "orchestration graph",
+        maxBytes: 64 * 1024,
+        maxChunks: 1024,
+    });
+    let rawGraph;
+    try {
+        rawGraph = JSON.parse(graphText);
+    }
+    catch {
+        throw new CliArgumentError("Standard input must be one valid JSON graph.");
+    }
+    const graph = orchestrationTaskGraphSchema.safeParse(rawGraph);
+    if (!graph.success) {
+        throw new CliArgumentError("Standard input is not a valid Task graph.");
+    }
+    return graph.data;
+};
+const runCreate = async (tokens, context) => {
+    const { parsed, terminalId, workspaceId } = parseRunCreateScope(tokens);
+    const graph = await readTaskGraph(context);
+    const result = await context.dependencies.createRun({
+        graph,
+        terminalId,
+        workspaceId,
+        ...mutationCommandId(parsed),
+    });
+    return writeRunCreateResult(result, context);
+};
+const runShow = async (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set());
+    requirePositionals(parsed.positionals, 1, "maia run show <run-id>");
+    const runId = parsed.positionals[0];
+    if (runId === undefined)
+        throw new CliArgumentError("The Run ID is missing.");
+    const result = await context.dependencies.showRun(runId);
+    return writeRunShowResult(result, context);
+};
+const runList = async (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set(["--after", "--limit", "--workspace"]));
+    requirePositionals(parsed.positionals, 0, "maia run list --workspace <id>");
+    const workspaceId = parsed.options.get("--workspace");
+    if (workspaceId === undefined) {
+        throw new CliArgumentError("Option '--workspace' is required.");
+    }
+    const result = await context.dependencies.listRuns({
+        afterCursor: readCursor(parsed.options.get("--after")),
+        limit: readPageSize(parsed.options.get("--limit")),
+        workspaceId,
+    });
+    return writeRunListResult(result, context, workspaceId);
+};
+const readTaskListPageSize = (value) => {
+    if (value === undefined)
+        return DEFAULT_ORCHESTRATION_TASK_LIST_PAGE_SIZE;
+    if (!/^(?:[1-9]|[12]\d|3[0-2])$/u.test(value)) {
+        throw new CliArgumentError("Option '--limit' must be an integer from 1 to 32.");
+    }
+    return Number(value);
+};
+const runTaskList = async (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set(["--after", "--limit"]));
+    requirePositionals(parsed.positionals, 1, "maia run task list <run-id>");
+    const runId = parsed.positionals[0];
+    if (runId === undefined)
+        throw new CliArgumentError("The Run ID is missing.");
+    const result = await context.dependencies.listTasks({
+        afterCursor: readCursor(parsed.options.get("--after")),
+        limit: readTaskListPageSize(parsed.options.get("--limit")),
+        runId,
+    });
+    return writeTaskListResult(result, context);
+};
+const runTaskShow = async (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set());
+    requirePositionals(parsed.positionals, 2, "maia run task show <run-id> <task-id>");
+    const [runId, taskId] = parsed.positionals;
+    if (runId === undefined || taskId === undefined) {
+        throw new CliArgumentError("The Task show scope is incomplete.");
+    }
+    const result = await context.dependencies.showTask({ runId, taskId });
+    return writeTaskShowResult(result, context);
+};
+const inboxOwner = (parsed, runId) => {
+    const kind = requireOption(parsed, "--owner");
+    if (kind !== "run" && kind !== "dispatch") {
+        throw new CliArgumentError("Option '--owner' must be run or dispatch.");
+    }
+    const id = requireOption(parsed, "--owner-id");
+    if (kind === "run" && id !== runId) {
+        throw new CliArgumentError("A Run inbox owner ID must equal the Run ID.");
+    }
+    return { id, kind };
+};
+const inboxCheck = async (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set(["--coordinator-epoch", "--limit", "--owner", "--owner-id"]));
+    requirePositionals(parsed.positionals, 1, "maia run inbox check <run-id>");
+    const runId = parsed.positionals[0];
+    if (runId === undefined)
+        throw new CliArgumentError("The Run ID is missing.");
+    const limitValue = parsed.options.get("--limit") ?? "8";
+    if (!/^(?:[1-9]|1[0-6])$/u.test(limitValue)) {
+        throw new CliArgumentError("Option '--limit' must be from 1 to 16.");
+    }
+    const result = await context.dependencies.checkRunInbox({
+        coordinatorEpoch: coordinatorEpoch(parsed),
+        limit: Number(limitValue),
+        owner: inboxOwner(parsed, runId),
+        runId,
+    });
+    return writeInboxCheckResult(result, context);
+};
+const inboxAckOptions = new Set([
+    "--command-id",
+    "--coordinator-epoch",
+    "--delivery-id",
+    "--expected-mailbox-revision",
+    "--owner",
+    "--owner-id",
+]);
+const inboxAck = async (tokens, context) => {
+    const parsed = parseOptions(tokens, inboxAckOptions);
+    requirePositionals(parsed.positionals, 1, "maia run inbox ack <run-id>");
+    const runId = parsed.positionals[0];
+    if (runId === undefined)
+        throw new CliArgumentError("The Run ID is missing.");
+    const result = await context.dependencies.acknowledgeRunDelivery({
+        coordinatorEpoch: coordinatorEpoch(parsed),
+        deliveryId: requireOption(parsed, "--delivery-id"),
+        expectedMailboxRevision: revision(parsed, "--expected-mailbox-revision"),
+        owner: inboxOwner(parsed, runId),
+        runId,
+        ...mutationCommandId(parsed),
+    });
+    return writeInboxAckResult(result, context);
+};
+const questionScopeOptions = [
+    "--command-id",
+    "--coordinator-epoch",
+    "--expected-dispatch-revision",
+    "--expected-run-revision",
+];
+const runDispatchIdentifiers = (parsed, usage, label) => {
+    requirePositionals(parsed.positionals, 2, usage);
+    const [runId, dispatchId] = parsed.positionals;
+    if (runId === undefined || dispatchId === undefined) {
+        throw new CliArgumentError(`The ${label} scope is incomplete.`);
+    }
+    return { dispatchId, runId };
+};
+const questionIdentifiers = (parsed, usage) => {
+    requirePositionals(parsed.positionals, 3, usage);
+    const [runId, dispatchId, questionId] = parsed.positionals;
+    if (runId === undefined ||
+        dispatchId === undefined ||
+        questionId === undefined) {
+        throw new CliArgumentError("The Question scope is incomplete.");
+    }
+    return { dispatchId, questionId, runId };
+};
+const parseQuestionOpen = (tokens) => {
+    const parsed = parseOptions(tokens, new Set([...questionScopeOptions, "--subject"]), new Set(["--body-stdin"]));
+    const identifiers = runDispatchIdentifiers(parsed, "maia run question open <run-id> <dispatch-id>", "Question");
+    if (!parsed.flags.has("--body-stdin")) {
+        throw new CliArgumentError("Option '--body-stdin' is required.");
+    }
+    const input = {
+        ...questionScope(parsed, identifiers.runId, identifiers.dispatchId),
+        subject: requireOption(parsed, "--subject"),
+    };
+    if (!orchestrationQuestionOpenParametersSchema.safeParse({
+        ...input,
+        body: "validated-after-metadata",
+        commandId: input.commandId ?? "command_metadata_validation",
+    }).success) {
+        throw new CliArgumentError("The Question-open metadata is invalid.");
+    }
+    return input;
+};
+const questionOpen = async (tokens, context) => {
+    const input = parseQuestionOpen(tokens);
+    if (context.io.stdin === undefined) {
+        throw new CliArgumentError("Standard input is unavailable.");
+    }
+    const body = await context.io.stdin({
+        label: "Question body",
+        maxBytes: 4 * 1024,
+        maxChunks: 256,
+    });
+    const result = await context.dependencies.openRunQuestion({
+        ...input,
+        body,
+    });
+    return writeQuestionOpenResult(result, context);
+};
+const parseQuestionReply = (tokens) => {
+    const parsed = parseOptions(tokens, new Set([...questionScopeOptions, "--expected-question-revision"]), new Set(["--answer-stdin"]));
+    const identifiers = questionIdentifiers(parsed, "maia run question reply <run-id> <dispatch-id> <question-id>");
+    if (!parsed.flags.has("--answer-stdin")) {
+        throw new CliArgumentError("Option '--answer-stdin' is required.");
+    }
+    const input = {
+        ...questionScope(parsed, identifiers.runId, identifiers.dispatchId),
+        expectedQuestionRevision: revision(parsed, "--expected-question-revision"),
+        questionId: identifiers.questionId,
+    };
+    if (!orchestrationQuestionReplyParametersSchema.safeParse({
+        ...input,
+        answer: "validated-after-metadata",
+        commandId: input.commandId ?? "command_metadata_validation",
+    }).success) {
+        throw new CliArgumentError("The Question-reply metadata is invalid.");
+    }
+    return input;
+};
+const questionReply = async (tokens, context) => {
+    const input = parseQuestionReply(tokens);
+    if (context.io.stdin === undefined) {
+        throw new CliArgumentError("Standard input is unavailable.");
+    }
+    const answer = await context.io.stdin({
+        label: "Question answer",
+        maxBytes: 4 * 1024,
+        maxChunks: 256,
+    });
+    const result = await context.dependencies.replyRunQuestion({
+        ...input,
+        answer,
+    });
+    return writeQuestionReplyResult(result, context);
+};
+const questionCancel = async (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set([...questionScopeOptions, "--expected-question-revision"]));
+    const { dispatchId, questionId, runId } = questionIdentifiers(parsed, "maia run question cancel <run-id> <dispatch-id> <question-id>");
+    const result = await context.dependencies.cancelRunQuestion({
+        ...questionScope(parsed, runId, dispatchId),
+        expectedQuestionRevision: revision(parsed, "--expected-question-revision"),
+        questionId,
+    });
+    return writeQuestionCancelResult(result, context);
+};
+const runDispatchShow = async (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set());
+    requirePositionals(parsed.positionals, 1, "maia run dispatch show <run-id>");
+    const runId = parsed.positionals[0];
+    if (runId === undefined)
+        throw new CliArgumentError("The Run ID is missing.");
+    const result = await context.dependencies.showDispatch(runId);
+    return writeDispatchShowResult(result, context);
+};
+const dispatchSettle = async (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set(questionScopeOptions));
+    const { dispatchId, runId } = runDispatchIdentifiers(parsed, "maia run dispatch settle-terminal <run-id> <dispatch-id>", "Dispatch");
+    const result = await context.dependencies.settleRunDispatchTerminal(questionScope(parsed, runId, dispatchId));
+    return writeDispatchSettleResult(result, context);
+};
+const runDispatchCommand = (nested, tokens, context) => {
+    if (nested === "show")
+        return runDispatchShow(tokens, context);
+    if (nested === "settle-terminal")
+        return dispatchSettle(tokens, context);
+    throw new CliArgumentError("Usage: maia run <create|list|show|task list|task show|inbox check|inbox ack|question open|question reply|question cancel|dispatch show|dispatch settle-terminal>");
+};
+export const runOrchestrationCommand = (tokens, context) => {
+    const [subcommand, nested, ...rest] = tokens;
+    if (subcommand === "create")
+        return runCreate(tokens.slice(1), context);
+    if (subcommand === "list")
+        return runList(tokens.slice(1), context);
+    if (subcommand === "show")
+        return runShow(tokens.slice(1), context);
+    if (subcommand === "task" && nested === "list")
+        return runTaskList(rest, context);
+    if (subcommand === "task" && nested === "show")
+        return runTaskShow(rest, context);
+    if (subcommand === "inbox" && nested === "check")
+        return inboxCheck(rest, context);
+    if (subcommand === "inbox" && nested === "ack")
+        return inboxAck(rest, context);
+    if (subcommand === "question" && nested === "open")
+        return questionOpen(rest, context);
+    if (subcommand === "question" && nested === "reply")
+        return questionReply(rest, context);
+    if (subcommand === "question" && nested === "cancel")
+        return questionCancel(rest, context);
+    if (subcommand === "dispatch") {
+        return runDispatchCommand(nested, rest, context);
+    }
+    throw new CliArgumentError("Usage: maia run <create|list|show|task list|task show|inbox check|inbox ack|question open|question reply|question cancel|dispatch show|dispatch settle-terminal>");
+};
+//# sourceMappingURL=commands.js.map

package/dist/orchestration/compact-aggregate.d.ts

@@ -0,0 +1,123 @@
+import type { OrchestrationAggregate, OrchestrationDelivery, OrchestrationDispatchSettleTerminalResult, OrchestrationDispatchShowResult, OrchestrationInboxAckResult, OrchestrationQuestion, OrchestrationQuestionCancelResult, OrchestrationQuestionOpenResult, OrchestrationQuestionReplyResult, OrchestrationRunCreateResult, OrchestrationRunShowResult } from "@maiaos/sdk";
+type ProtocolDispatch = OrchestrationDispatchShowResult["dispatch"];
+type ProtocolReceipt = OrchestrationRunCreateResult["receipt"];
+export type CliDispatchShowDispatch = {
+    readonly attemptId: ProtocolDispatch["attemptId"];
+    readonly failure?: Extract<ProtocolDispatch, {
+        readonly state: "failed";
+    }>["failure"];
+    readonly id: ProtocolDispatch["id"];
+    readonly revision: ProtocolDispatch["revision"];
+    readonly runId: ProtocolDispatch["runId"];
+    readonly state: ProtocolDispatch["state"];
+    readonly taskId: ProtocolDispatch["taskId"];
+    readonly terminalId: ProtocolDispatch["terminalId"];
+};
+export type CliCompactMailbox = {
+    readonly id: OrchestrationAggregate["mailboxes"][number]["id"];
+    readonly owner: OrchestrationAggregate["mailboxes"][number]["owner"];
+    readonly revision: OrchestrationAggregate["mailboxes"][number]["revision"];
+};
+export type CliCompactQuestion = {
+    readonly answer?: Extract<OrchestrationQuestion, {
+        readonly state: "answered";
+    }>["answer"];
+    readonly body: OrchestrationQuestion["body"];
+    readonly id: OrchestrationQuestion["id"];
+    readonly revision: OrchestrationQuestion["revision"];
+    readonly state: OrchestrationQuestion["state"];
+    readonly subject: OrchestrationQuestion["subject"];
+    readonly taskId: OrchestrationQuestion["taskId"];
+};
+export type CliCompactAggregate = {
+    readonly attempt: {
+        readonly id: OrchestrationAggregate["attempt"]["id"];
+        readonly revision: OrchestrationAggregate["attempt"]["revision"];
+        readonly state: OrchestrationAggregate["attempt"]["state"];
+        readonly taskId: OrchestrationAggregate["attempt"]["taskId"];
+    };
+    readonly dispatch: CliDispatchShowDispatch;
+    readonly mailboxes: readonly CliCompactMailbox[];
+    readonly question?: CliCompactQuestion;
+    readonly run: {
+        readonly dispatchTaskId: OrchestrationAggregate["run"]["dispatchTaskId"];
+        readonly id: OrchestrationAggregate["run"]["id"];
+        readonly revision: OrchestrationAggregate["run"]["revision"];
+        readonly rootTaskId: OrchestrationAggregate["run"]["rootTaskId"];
+        readonly state: OrchestrationAggregate["run"]["state"];
+        readonly terminalId: OrchestrationAggregate["run"]["terminalId"];
+        readonly workspaceId: OrchestrationAggregate["run"]["workspaceId"];
+    };
+    readonly taskCount: number;
+};
+export type CliCompactDelivery = {
+    readonly deliveryId: OrchestrationDelivery["id"];
+    readonly mailboxId: OrchestrationDelivery["mailboxId"];
+    readonly questionId?: string;
+    readonly sequence: OrchestrationDelivery["sequence"];
+    readonly subject: OrchestrationDelivery["message"]["subject"];
+    readonly type: OrchestrationDelivery["message"]["type"];
+};
+export type CliCompactReceipt = {
+    readonly aggregateRevision: ProtocolReceipt["aggregateRevision"];
+    readonly commandId: ProtocolReceipt["commandId"];
+    readonly receiptId: ProtocolReceipt["receiptId"];
+    readonly state: ProtocolReceipt["state"];
+    readonly target: ProtocolReceipt["target"];
+};
+export type CliRunShowResult = {
+    readonly aggregate: CliCompactAggregate;
+    readonly command: "run.show";
+};
+export type CliRunCreateResult = {
+    readonly aggregate: CliCompactAggregate;
+    readonly command: "run.create";
+    readonly delivery: OrchestrationRunCreateResult["delivery"];
+    readonly initialDelivery: CliCompactDelivery;
+    readonly receipt: CliCompactReceipt;
+};
+export type CliQuestionOpenResult = {
+    readonly aggregate: CliCompactAggregate;
+    readonly command: "run.question.open";
+    readonly delivery: CliCompactDelivery;
+    readonly receipt: CliCompactReceipt;
+};
+export type CliQuestionReplyResult = {
+    readonly aggregate: CliCompactAggregate;
+    readonly command: "run.question.reply";
+    readonly delivery: CliCompactDelivery;
+    readonly receipt: CliCompactReceipt;
+};
+export type CliQuestionCancelResult = {
+    readonly aggregate: CliCompactAggregate;
+    readonly command: "run.question.cancel";
+    readonly receipt: CliCompactReceipt;
+};
+export type CliDispatchSettleResult = {
+    readonly aggregate: CliCompactAggregate;
+    readonly command: "run.dispatch.settle-terminal";
+    readonly delivery: CliCompactDelivery;
+    readonly receipt: CliCompactReceipt;
+};
+export type CliInboxAckResult = {
+    readonly command: "run.inbox.ack";
+    readonly delivery: CliCompactDelivery;
+    readonly mailboxId: OrchestrationInboxAckResult["mailbox"]["id"];
+    readonly mailboxRevision: OrchestrationInboxAckResult["mailbox"]["revision"];
+    readonly owner: OrchestrationInboxAckResult["mailbox"]["owner"];
+    readonly receipt: CliCompactReceipt;
+    readonly runId: OrchestrationInboxAckResult["mailbox"]["runId"];
+};
+export declare const projectDispatchShowDispatch: (dispatch: ProtocolDispatch) => CliDispatchShowDispatch;
+export declare const projectOrchestrationAggregate: (aggregate: OrchestrationAggregate) => CliCompactAggregate;
+export declare const projectOrchestrationDelivery: (delivery: OrchestrationDelivery) => CliCompactDelivery;
+export declare const projectOrchestrationReceipt: (receipt: ProtocolReceipt) => CliCompactReceipt;
+export declare const projectRunShowResult: (value: OrchestrationRunShowResult) => CliRunShowResult;
+export declare const projectRunCreateResult: (value: OrchestrationRunCreateResult) => CliRunCreateResult;
+export declare const projectQuestionOpenResult: (value: OrchestrationQuestionOpenResult) => CliQuestionOpenResult;
+export declare const projectQuestionReplyResult: (value: OrchestrationQuestionReplyResult) => CliQuestionReplyResult;
+export declare const projectQuestionCancelResult: (value: OrchestrationQuestionCancelResult) => CliQuestionCancelResult;
+export declare const projectDispatchSettleResult: (value: OrchestrationDispatchSettleTerminalResult) => CliDispatchSettleResult;
+export declare const projectInboxAckResult: (value: OrchestrationInboxAckResult) => CliInboxAckResult;
+export {};
+//# sourceMappingURL=compact-aggregate.d.ts.map