@maiaos/cli 0.1.0-canary.2

package/dist/orchestration/commands.js

@@ -0,0 +1,312 @@
+import { DEFAULT_ORCHESTRATION_TASK_LIST_PAGE_SIZE, orchestrationQuestionOpenParametersSchema, orchestrationQuestionReplyParametersSchema, orchestrationTaskGraphSchema, } from "@maiaos/sdk";
+import * as Effect from "effect/Effect";
+import { CliArgumentError, decodeJsonText, parseOptions, readCursor, readExpectedRevision, readPageSize, requirePositionals, } from "../command-line/index.js";
+import { writeDispatchSettleResult, writeDispatchShowResult, writeInboxAckResult, writeInboxCheckResult, writeQuestionCancelResult, writeQuestionOpenResult, writeQuestionReplyResult, writeRunCreateResult, writeRunListResult, writeRunShowResult, writeTaskListResult, writeTaskShowResult, } from "./output/index.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", "--terminal", "--workspace"]), new Set(["--graph-stdin"]));
+    requirePositionals(parsed.positionals, 0);
+    if (!parsed.flags.has("--graph-stdin")) {
+        throw new CliArgumentError("Option '--graph-stdin' is required.");
+    }
+    return {
+        parsed,
+        terminalId: requireOption(parsed, "--terminal"),
+        workspaceId: requireOption(parsed, "--workspace"),
+    };
+};
+const readTaskGraph = (context) => {
+    const stdin = context.io.stdin;
+    if (stdin === undefined) {
+        throw new CliArgumentError("Standard input is unavailable.");
+    }
+    return stdin({
+        label: "orchestration graph",
+        maxBytes: 64 * 1024,
+        maxChunks: 1024,
+    }).pipe(Effect.flatMap((graphText) => decodeJsonText(graphText, () => new CliArgumentError("Standard input must be one valid JSON graph."))), Effect.flatMap((rawGraph) => {
+        const graph = orchestrationTaskGraphSchema.safeParse(rawGraph);
+        return graph.success
+            ? Effect.succeed(graph.data)
+            : Effect.fail(new CliArgumentError("Standard input is not a valid Task graph."));
+    }));
+};
+export const runCreate = (tokens, context) => Effect.gen(function* () {
+    const { parsed, terminalId, workspaceId } = parseRunCreateScope(tokens);
+    const graph = yield* readTaskGraph(context);
+    const result = yield* context.dependencies.createRun({
+        graph,
+        terminalId,
+        workspaceId,
+        ...mutationCommandId(parsed),
+    });
+    return writeRunCreateResult(result, context);
+});
+export const runShow = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set());
+    requirePositionals(parsed.positionals, 1);
+    const runId = parsed.positionals[0];
+    if (runId === undefined)
+        throw new CliArgumentError("The Run ID is missing.");
+    const result = yield* context.dependencies.showRun(runId);
+    return writeRunShowResult(result, context);
+});
+export const runList = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set(["--after", "--limit", "--workspace"]));
+    requirePositionals(parsed.positionals, 0);
+    const workspaceId = parsed.options.get("--workspace");
+    if (workspaceId === undefined) {
+        throw new CliArgumentError("Option '--workspace' is required.");
+    }
+    const result = yield* 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);
+};
+export const runTaskList = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set(["--after", "--limit", "--run"]));
+    requirePositionals(parsed.positionals, 0);
+    const runId = requireOption(parsed, "--run");
+    const result = yield* context.dependencies.listTasks({
+        afterCursor: readCursor(parsed.options.get("--after")),
+        limit: readTaskListPageSize(parsed.options.get("--limit")),
+        runId,
+    });
+    return writeTaskListResult(result, context);
+});
+export const runTaskShow = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set(["--run"]));
+    requirePositionals(parsed.positionals, 1);
+    const runId = requireOption(parsed, "--run");
+    const taskId = parsed.positionals[0];
+    if (taskId === undefined) {
+        throw new CliArgumentError("The Task ID is missing.");
+    }
+    const result = yield* 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 };
+};
+export const runInboxCheck = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set([
+        "--coordinator-epoch",
+        "--limit",
+        "--owner",
+        "--owner-id",
+        "--run",
+    ]));
+    requirePositionals(parsed.positionals, 0);
+    const runId = requireOption(parsed, "--run");
+    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 = yield* 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",
+    "--expected-mailbox-revision",
+    "--owner",
+    "--owner-id",
+    "--run",
+]);
+export const runInboxAck = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, inboxAckOptions);
+    requirePositionals(parsed.positionals, 1);
+    const runId = requireOption(parsed, "--run");
+    const deliveryId = parsed.positionals[0];
+    if (deliveryId === undefined)
+        throw new CliArgumentError("The delivery ID is missing.");
+    const result = yield* context.dependencies.acknowledgeRunDelivery({
+        coordinatorEpoch: coordinatorEpoch(parsed),
+        deliveryId,
+        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",
+    "--run",
+];
+const runDispatchIdentifiers = (parsed) => {
+    requirePositionals(parsed.positionals, 0);
+    return {
+        dispatchId: requireOption(parsed, "--dispatch"),
+        runId: requireOption(parsed, "--run"),
+    };
+};
+const questionIdentifiers = (parsed) => {
+    requirePositionals(parsed.positionals, 1);
+    const questionId = parsed.positionals[0];
+    if (questionId === undefined)
+        throw new CliArgumentError("The Question ID is missing.");
+    return {
+        dispatchId: requireOption(parsed, "--dispatch"),
+        questionId,
+        runId: requireOption(parsed, "--run"),
+    };
+};
+const parseQuestionOpen = (tokens) => {
+    const parsed = parseOptions(tokens, new Set([...questionScopeOptions, "--dispatch", "--subject"]), new Set(["--body-stdin"]));
+    const identifiers = runDispatchIdentifiers(parsed);
+    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;
+};
+export const runQuestionOpen = (tokens, context) => Effect.gen(function* () {
+    const input = parseQuestionOpen(tokens);
+    if (context.io.stdin === undefined) {
+        throw new CliArgumentError("Standard input is unavailable.");
+    }
+    const body = yield* context.io.stdin({
+        label: "Question body",
+        maxBytes: 4 * 1024,
+        maxChunks: 256,
+    });
+    const result = yield* context.dependencies.openRunQuestion({
+        ...input,
+        body,
+    });
+    return writeQuestionOpenResult(result, context);
+});
+const parseQuestionReply = (tokens) => {
+    const parsed = parseOptions(tokens, new Set([
+        ...questionScopeOptions,
+        "--dispatch",
+        "--expected-question-revision",
+    ]), new Set(["--answer-stdin"]));
+    const identifiers = questionIdentifiers(parsed);
+    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;
+};
+export const runQuestionReply = (tokens, context) => Effect.gen(function* () {
+    const input = parseQuestionReply(tokens);
+    if (context.io.stdin === undefined) {
+        throw new CliArgumentError("Standard input is unavailable.");
+    }
+    const answer = yield* context.io.stdin({
+        label: "Question answer",
+        maxBytes: 4 * 1024,
+        maxChunks: 256,
+    });
+    const result = yield* context.dependencies.replyRunQuestion({
+        ...input,
+        answer,
+    });
+    return writeQuestionReplyResult(result, context);
+});
+export const runQuestionCancel = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set([
+        ...questionScopeOptions,
+        "--dispatch",
+        "--expected-question-revision",
+    ]));
+    const { dispatchId, questionId, runId } = questionIdentifiers(parsed);
+    const result = yield* context.dependencies.cancelRunQuestion({
+        ...questionScope(parsed, runId, dispatchId),
+        expectedQuestionRevision: revision(parsed, "--expected-question-revision"),
+        questionId,
+    });
+    return writeQuestionCancelResult(result, context);
+});
+export const runDispatchShow = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set(["--run"]));
+    requirePositionals(parsed.positionals, 0);
+    const runId = requireOption(parsed, "--run");
+    const result = yield* context.dependencies.showDispatch(runId);
+    return writeDispatchShowResult(result, context);
+});
+export const runDispatchSettleTerminal = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set(questionScopeOptions));
+    requirePositionals(parsed.positionals, 1);
+    const runId = requireOption(parsed, "--run");
+    const dispatchId = parsed.positionals[0];
+    if (dispatchId === undefined)
+        throw new CliArgumentError("The Dispatch ID is missing.");
+    const result = yield* context.dependencies.settleRunDispatchTerminal(questionScope(parsed, runId, dispatchId));
+    return writeDispatchSettleResult(result, context);
+});
+//# sourceMappingURL=commands.js.map

package/dist/orchestration/index.d.ts

@@ -0,0 +1,3 @@
+export { makeOrchestrationClient } from "./client.js";
+export { runCreate, runDispatchSettleTerminal, runDispatchShow, runInboxAck, runInboxCheck, runList, runQuestionCancel, runQuestionOpen, runQuestionReply, runShow, runTaskList, runTaskShow, } from "./commands.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/orchestration/index.js

@@ -0,0 +1,3 @@
+export { makeOrchestrationClient } from "./client.js";
+export { runCreate, runDispatchSettleTerminal, runDispatchShow, runInboxAck, runInboxCheck, runList, runQuestionCancel, runQuestionOpen, runQuestionReply, runShow, runTaskList, runTaskShow, } from "./commands.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,121 @@
+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"];
+};
+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"];
+};
+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"];
+};
+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 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

package/dist/orchestration/output/compact-aggregate.js

@@ -0,0 +1,110 @@
+export const projectDispatchShowDispatch = (dispatch) => ({
+    attemptId: dispatch.attemptId,
+    ...(dispatch.state === "failed" ? { failure: dispatch.failure } : {}),
+    id: dispatch.id,
+    revision: dispatch.revision,
+    runId: dispatch.runId,
+    state: dispatch.state,
+    taskId: dispatch.taskId,
+    terminalId: dispatch.terminalId,
+});
+const projectMailbox = (mailbox) => ({
+    id: mailbox.id,
+    owner: { id: mailbox.owner.id, kind: mailbox.owner.kind },
+    revision: mailbox.revision,
+});
+const projectQuestion = (question) => ({
+    ...(question.state === "answered" ? { answer: question.answer } : {}),
+    body: question.body,
+    id: question.id,
+    revision: question.revision,
+    state: question.state,
+    subject: question.subject,
+    taskId: question.taskId,
+});
+export const projectOrchestrationAggregate = (aggregate) => ({
+    attempt: {
+        id: aggregate.attempt.id,
+        revision: aggregate.attempt.revision,
+        state: aggregate.attempt.state,
+        taskId: aggregate.attempt.taskId,
+    },
+    dispatch: projectDispatchShowDispatch(aggregate.dispatch),
+    mailboxes: [...aggregate.mailboxes]
+        .map(projectMailbox)
+        .sort((left, right) => left.owner.kind.localeCompare(right.owner.kind)),
+    ...(aggregate.question === undefined
+        ? {}
+        : { question: projectQuestion(aggregate.question) }),
+    run: {
+        dispatchTaskId: aggregate.run.dispatchTaskId,
+        id: aggregate.run.id,
+        revision: aggregate.run.revision,
+        rootTaskId: aggregate.run.rootTaskId,
+        state: aggregate.run.state,
+        terminalId: aggregate.run.terminalId,
+        workspaceId: aggregate.run.workspaceId,
+    },
+    taskCount: aggregate.tasks.length,
+});
+const projectOrchestrationDelivery = (delivery) => ({
+    deliveryId: delivery.id,
+    mailboxId: delivery.mailboxId,
+    ...("questionId" in delivery.message
+        ? { questionId: delivery.message.questionId }
+        : {}),
+    sequence: delivery.sequence,
+    subject: delivery.message.subject,
+    type: delivery.message.type,
+});
+const projectOrchestrationReceipt = (receipt) => ({
+    aggregateRevision: receipt.aggregateRevision,
+    commandId: receipt.commandId,
+    receiptId: receipt.receiptId,
+    state: receipt.state,
+    target: receipt.target,
+});
+export const projectRunShowResult = (value) => ({
+    aggregate: projectOrchestrationAggregate(value.aggregate),
+    command: "run.show",
+});
+export const projectRunCreateResult = (value) => ({
+    aggregate: projectOrchestrationAggregate(value.aggregate),
+    command: "run.create",
+    delivery: value.delivery,
+    initialDelivery: projectOrchestrationDelivery(value.initialDelivery),
+    receipt: projectOrchestrationReceipt(value.receipt),
+});
+export const projectQuestionOpenResult = (value) => ({
+    aggregate: projectOrchestrationAggregate(value.aggregate),
+    command: "run.question.open",
+    delivery: projectOrchestrationDelivery(value.delivery),
+    receipt: projectOrchestrationReceipt(value.receipt),
+});
+export const projectQuestionReplyResult = (value) => ({
+    aggregate: projectOrchestrationAggregate(value.aggregate),
+    command: "run.question.reply",
+    delivery: projectOrchestrationDelivery(value.delivery),
+    receipt: projectOrchestrationReceipt(value.receipt),
+});
+export const projectQuestionCancelResult = (value) => ({
+    aggregate: projectOrchestrationAggregate(value.aggregate),
+    command: "run.question.cancel",
+    receipt: projectOrchestrationReceipt(value.receipt),
+});
+export const projectDispatchSettleResult = (value) => ({
+    aggregate: projectOrchestrationAggregate(value.aggregate),
+    command: "run.dispatch.settle-terminal",
+    delivery: projectOrchestrationDelivery(value.delivery),
+    receipt: projectOrchestrationReceipt(value.receipt),
+});
+export const projectInboxAckResult = (value) => ({
+    command: "run.inbox.ack",
+    delivery: projectOrchestrationDelivery(value.delivery),
+    mailboxId: value.mailbox.id,
+    mailboxRevision: value.mailbox.revision,
+    owner: { id: value.mailbox.owner.id, kind: value.mailbox.owner.kind },
+    receipt: projectOrchestrationReceipt(value.receipt),
+    runId: value.mailbox.runId,
+});
+//# sourceMappingURL=compact-aggregate.js.map

package/dist/orchestration/output/compact-run-list.d.ts

@@ -0,0 +1,20 @@
+import type { OrchestrationRun, OrchestrationRunListResult } from "@maiaos/sdk";
+type CliRunListItem = {
+    readonly dispatchTaskId: OrchestrationRun["dispatchTaskId"];
+    readonly id: OrchestrationRun["id"];
+    readonly revision: OrchestrationRun["revision"];
+    readonly rootTaskId: OrchestrationRun["rootTaskId"];
+    readonly state: OrchestrationRun["state"];
+    readonly terminalId: OrchestrationRun["terminalId"];
+};
+export type CliRunListResult = {
+    readonly command: "run.list";
+    readonly count: number;
+    readonly items: readonly CliRunListItem[];
+    readonly nextCursor?: OrchestrationRunListResult["nextCursor"];
+    readonly workspaceId: OrchestrationRun["workspaceId"];
+};
+export declare const projectRunListItem: (run: OrchestrationRun) => CliRunListItem;
+export declare const projectRunListResult: (value: OrchestrationRunListResult, workspaceId: OrchestrationRun["workspaceId"]) => CliRunListResult;
+export {};
+//# sourceMappingURL=compact-run-list.d.ts.map

package/dist/orchestration/output/compact-run-list.js

@@ -0,0 +1,16 @@
+export const projectRunListItem = (run) => ({
+    dispatchTaskId: run.dispatchTaskId,
+    id: run.id,
+    revision: run.revision,
+    rootTaskId: run.rootTaskId,
+    state: run.state,
+    terminalId: run.terminalId,
+});
+export const projectRunListResult = (value, workspaceId) => ({
+    command: "run.list",
+    count: value.items.length,
+    items: value.items.map(projectRunListItem),
+    ...(value.nextCursor === undefined ? {} : { nextCursor: value.nextCursor }),
+    workspaceId: value.items[0]?.workspaceId ?? workspaceId,
+});
+//# sourceMappingURL=compact-run-list.js.map

package/dist/orchestration/output/human.d.ts

@@ -0,0 +1,80 @@
+import type { OrchestrationDispatchShowResult, OrchestrationInboxCheckResult, OrchestrationRunListResult, OrchestrationTaskListResult, OrchestrationTaskShowResult } from "@maiaos/sdk";
+import { type CliIo } from "../../command-line/index.js";
+import type { CliNodeResult } from "../../local-node/index.js";
+import { type CliDispatchSettleResult, type CliDispatchShowDispatch, type CliInboxAckResult, type CliQuestionCancelResult, type CliQuestionOpenResult, type CliQuestionReplyResult, type CliRunCreateResult, type CliRunShowResult, projectDispatchSettleResult, projectInboxAckResult, projectQuestionCancelResult, projectQuestionOpenResult, projectQuestionReplyResult, projectRunCreateResult, projectRunShowResult } from "./compact-aggregate.js";
+import { type CliRunListResult } from "./compact-run-list.js";
+type OutputContext = {
+    readonly io: CliIo;
+    readonly json: boolean;
+};
+type CliInboxCheckItem = {
+    readonly body: OrchestrationInboxCheckResult["items"][number]["message"]["body"];
+    readonly deliveryId: OrchestrationInboxCheckResult["items"][number]["id"];
+    readonly mailboxId: OrchestrationInboxCheckResult["items"][number]["mailboxId"];
+    readonly sequence: OrchestrationInboxCheckResult["items"][number]["sequence"];
+    readonly subject: OrchestrationInboxCheckResult["items"][number]["message"]["subject"];
+    readonly type: OrchestrationInboxCheckResult["items"][number]["message"]["type"];
+};
+type CliInboxCheckResult = {
+    readonly command: "run.inbox.check";
+    readonly count: number;
+    readonly items: readonly CliInboxCheckItem[];
+    readonly mailboxId: OrchestrationInboxCheckResult["mailbox"]["id"];
+    readonly mailboxRevision: OrchestrationInboxCheckResult["mailbox"]["revision"];
+    readonly owner: OrchestrationInboxCheckResult["mailbox"]["owner"];
+    readonly runId: OrchestrationInboxCheckResult["mailbox"]["runId"];
+};
+type CliTaskListItem = {
+    readonly clientKey: OrchestrationTaskListResult["items"][number]["clientKey"];
+    readonly dependencyTaskIds: OrchestrationTaskListResult["items"][number]["dependencyTaskIds"];
+    readonly id: OrchestrationTaskListResult["items"][number]["id"];
+    readonly revision: OrchestrationTaskListResult["items"][number]["revision"];
+    readonly state: OrchestrationTaskListResult["items"][number]["state"];
+};
+type CliTaskListResult = {
+    readonly command: "run.task.list";
+    readonly count: number;
+    readonly items: readonly CliTaskListItem[];
+    readonly nextCursor?: OrchestrationTaskListResult["nextCursor"];
+    readonly runId: OrchestrationTaskListResult["runId"];
+};
+type CliTaskShowTask = {
+    readonly clientKey: OrchestrationTaskShowResult["task"]["clientKey"];
+    readonly dependencyTaskIds: OrchestrationTaskShowResult["task"]["dependencyTaskIds"];
+    readonly id: OrchestrationTaskShowResult["task"]["id"];
+    readonly objective: OrchestrationTaskShowResult["task"]["objective"];
+    readonly revision: OrchestrationTaskShowResult["task"]["revision"];
+    readonly runId: OrchestrationTaskShowResult["task"]["runId"];
+    readonly state: OrchestrationTaskShowResult["task"]["state"];
+};
+type CliTaskShowResult = {
+    readonly command: "run.task.show";
+    readonly task: CliTaskShowTask;
+};
+type CliDispatchShowResult = {
+    readonly command: "run.dispatch.show";
+    readonly dispatch: CliDispatchShowDispatch;
+};
+export type CliOrchestrationResult = CliDispatchSettleResult | CliDispatchShowResult | CliInboxAckResult | CliInboxCheckResult | CliQuestionCancelResult | CliQuestionOpenResult | CliQuestionReplyResult | CliRunCreateResult | CliRunListResult | CliRunShowResult | CliTaskListResult | CliTaskShowResult;
+export declare const formatInboxAck: (result: CliInboxAckResult) => string;
+export declare const formatRunList: (result: CliRunListResult) => string;
+export declare const formatRunShow: (result: CliRunShowResult) => string;
+export declare const formatRunCreate: (result: CliRunCreateResult) => string;
+export declare const formatQuestionOpen: (result: CliQuestionOpenResult) => string;
+export declare const formatQuestionCancel: (result: CliQuestionCancelResult) => string;
+export declare const formatCompactOrchestration: (result: CliOrchestrationResult) => string;
+type ProjectedWriter<TValue> = (result: CliNodeResult<TValue>, context: OutputContext) => number;
+export declare const writeInboxAckResult: ProjectedWriter<Parameters<typeof projectInboxAckResult>[0]>;
+export declare const writeInboxCheckResult: (result: CliNodeResult<OrchestrationInboxCheckResult>, context: OutputContext) => number;
+export declare const writeRunListResult: (result: CliNodeResult<OrchestrationRunListResult>, context: OutputContext, workspaceId: string) => number;
+export declare const writeTaskListResult: (result: CliNodeResult<OrchestrationTaskListResult>, context: OutputContext) => number;
+export declare const writeTaskShowResult: (result: CliNodeResult<OrchestrationTaskShowResult>, context: OutputContext) => number;
+export declare const writeDispatchShowResult: (result: CliNodeResult<OrchestrationDispatchShowResult>, context: OutputContext) => number;
+export declare const writeRunShowResult: ProjectedWriter<Parameters<typeof projectRunShowResult>[0]>;
+export declare const writeRunCreateResult: ProjectedWriter<Parameters<typeof projectRunCreateResult>[0]>;
+export declare const writeQuestionOpenResult: ProjectedWriter<Parameters<typeof projectQuestionOpenResult>[0]>;
+export declare const writeQuestionReplyResult: ProjectedWriter<Parameters<typeof projectQuestionReplyResult>[0]>;
+export declare const writeQuestionCancelResult: ProjectedWriter<Parameters<typeof projectQuestionCancelResult>[0]>;
+export declare const writeDispatchSettleResult: ProjectedWriter<Parameters<typeof projectDispatchSettleResult>[0]>;
+export {};
+//# sourceMappingURL=human.d.ts.map