@maiaos/cli 0.1.0-canary.2

package/dist/session/tree/tree.js

@@ -0,0 +1,309 @@
+const session = () => import("../index.js");
+const turn = () => import("../turn/index.js");
+const approval = () => import("../approval/index.js");
+const interaction = () => import("../interaction/index.js");
+const discovery = () => import("../../import/index.js");
+export const SESSION_TREE = {
+    groups: [
+        ["session", "Sessions: workers that run in a Workspace."],
+        ["session events", "A Session's events."],
+        ["session history", "Session transcripts."],
+        ["session inbox", "This Session's inbox."],
+        ["session message", "Messages between Sessions."],
+        ["session agent-permission", "Agent permission grants."],
+        ["session turn", "Turns sent to a Session."],
+        ["session approval", "What a worker waits on a person for."],
+        ["session interaction", "Record-only questions to a person."],
+        ["import", "Find sessions to adopt."],
+    ],
+    leaves: [
+        [
+            "session create (--workspace <workspace-id> | --project <project-id>) [--command-id <id>] [--role <worker|orchestrator>] [--connection <connection-id> [--executor <codex-cli|claude-code>] [--model <id>] | --executor <codex-cli|claude-code> | --agent-definition <key> --agent-definition-version <version> --agent-definition-digest <sha256>] [--base <branch-tag-or-commit>] [--title <text>] [--message <text> | --prompt-stdin | --from-file <path>]",
+            0,
+            "session.create",
+            "Create a Session, optionally starting it with a first message.",
+            {
+                example: "maia --json session create --executor codex-cli --message 'Fix the build' --command-id create-1",
+                run: [session, "runSessionCreate"],
+            },
+        ],
+        [
+            "session list (--project <project-id> | --all) [--state <state>[,<state>...]] [--attention] [--limit <1..100>] [--after <cursor>]",
+            0,
+            "session.list",
+            "List Sessions of a Project, or all of them.",
+            {
+                example: "maia --json session list --all --attention",
+                run: [session, "runSessionList"],
+            },
+        ],
+        [
+            "session show <session-id>",
+            0,
+            "session.show",
+            "Show one Session.",
+            {
+                example: "maia --json session show session_1",
+                run: [session, "runSessionShow"],
+            },
+        ],
+        [
+            "session rename <session-id> --title <text> --expected-revision <revision> [--command-id <id>]",
+            1,
+            "session.rename",
+            "Rename a Session at its current revision.",
+            {
+                example: "maia --json session rename session_1 --title 'Fix the build' --expected-revision 2",
+                run: [session, "runSessionRename"],
+            },
+        ],
+        [
+            "session start <session-id> --expected-revision <revision> [--command-id <id>] [--wait [--timeout <duration>]]",
+            1,
+            "session.start",
+            "Start a Session; --wait returns once it runs.",
+            {
+                example: "maia --json session start session_1 --expected-revision 1 --command-id start-1 --wait",
+                run: [session, "runSessionStart"],
+            },
+        ],
+        [
+            "session stop <session-id> --expected-revision <revision> [--command-id <id>]",
+            1,
+            "session.stop",
+            "Stop a Session.",
+            {
+                example: "maia --json session stop session_1 --expected-revision 2 --command-id stop-1",
+                run: [session, "runSessionStop"],
+            },
+        ],
+        [
+            "session resume <session-id> --expected-revision <revision> [--command-id <id>]",
+            1,
+            "session.resume",
+            "Resume a stopped Session.",
+            { run: [session, "runSessionResume"] },
+        ],
+        [
+            "session archive <session-id> --expected-revision <revision> [--command-id <id>]",
+            1,
+            "session.archive",
+            "Archive a Session and retire its worktree.",
+            {
+                example: "maia --json session archive session_1 --expected-revision 3 --command-id archive-1",
+                run: [session, "runSessionArchive"],
+            },
+        ],
+        [
+            "session diff <session-id> [--stat]",
+            1,
+            "session.diff",
+            "Show the changes a coding Session made.",
+            {
+                example: "maia session diff session_1 --stat",
+                run: [session, "runSessionDiff"],
+            },
+        ],
+        [
+            "session observe [<session-id>...] [--stall-after <duration>]",
+            0,
+            "session.observe",
+            "Stream Session state changes and stalls.",
+            {
+                example: "maia --json session observe --stall-after 5m",
+                run: [session, "runSessionObserve"],
+            },
+        ],
+        [
+            "session attach <session-id> [--after <epoch>:<sequence>] [--no-follow]",
+            1,
+            "session.attach",
+            "Follow a Session's live items.",
+            {
+                example: "maia session attach session_1",
+                run: [session, "runSessionAttach"],
+            },
+        ],
+        [
+            "session events list --session <session-id> [--limit <1..32>] [--after <session-cursor>]",
+            0,
+            "session.events.list",
+            "List a Session's events.",
+            { run: [session, "runSessionEventsList"] },
+        ],
+        [
+            "session history read <session-id|claude:<id>|codex:<id>> [--offset <n>] [--limit <1..50>]",
+            1,
+            "session.history.read",
+            "Read a Session's or vendor session's history.",
+            { run: [discovery, "runHistoryRead"] },
+        ],
+        [
+            "session adopt (<claude|codex>:<native-id> --workspace <workspace-id> [--attest-ended] [--command-id <id>] [--dry-run] | --confirm-stdin)",
+            1,
+            ["session.adopt.preview", "session.adopt.confirm"],
+            "Adopt a Claude Code or Codex session after a preview.",
+            {
+                example: "maia --json session adopt codex:019a --workspace workspace_1 --dry-run",
+                kind: "two-phase",
+                run: [discovery, "runAdopt"],
+            },
+        ],
+        [
+            "session agent-permission set (--input-stdin --dry-run | --confirm-stdin)",
+            1,
+            ["session.agent-permission.preview", "session.agent-permission.confirm"],
+            "Grant or change an agent permission after a preview.",
+            { kind: "two-phase", run: [session, "runAgentPermissionSet"] },
+        ],
+        [
+            "session message send --session <recipient-session-id> --attached --subject <text> --body-stdin [--command-id <id>]",
+            1,
+            "session.message.send",
+            "Send a message to another Session.",
+            { run: [session, "runSessionMessageSend"] },
+        ],
+        [
+            "session inbox check --attached [--limit <1..16>]",
+            1,
+            "session.inbox.check",
+            "Check this Session's inbox.",
+            { run: [session, "runSessionInboxCheck"] },
+        ],
+        [
+            "session inbox ack <delivery-id> --attached --expected-mailbox-revision <revision> [--command-id <id>]",
+            1,
+            "session.inbox.ack",
+            "Acknowledge one message delivered to this Session.",
+            { run: [session, "runSessionInboxAck"] },
+        ],
+        [
+            "session turn send --session <session-id> --prompt-stdin --expected-revision <revision> [--command-id <id>]",
+            1,
+            "turn.send",
+            "Send a turn to a Session from standard input.",
+            {
+                example: "printf %s 'Explain the build' | maia --json session turn send --session session_1 --prompt-stdin --expected-revision 2 --command-id send-1",
+                run: [turn, "runTurnSend"],
+            },
+        ],
+        [
+            "session turn show <turn-id> [--include-content]",
+            1,
+            "turn.show",
+            "Show one turn, its usage and, with --include-content, its text.",
+            {
+                example: "maia --json session turn show turn_1 --include-content",
+                run: [turn, "runTurnShow"],
+            },
+        ],
+        [
+            "session turn wait <turn-id>... [--any] [--timeout <duration>]",
+            1,
+            "turn.wait",
+            "Wait for turns to finish; a failed turn exits non-zero.",
+            {
+                example: "maia --json session turn wait turn_1 --timeout 10m",
+                run: [turn, "runTurnWait"],
+            },
+        ],
+        [
+            "session turn interrupt <turn-id> --expected-session-revision <revision> [--command-id <id>]",
+            1,
+            "turn.interrupt",
+            "Interrupt a running turn at its Session's revision.",
+            {
+                example: "maia --json session turn interrupt turn_1 --expected-session-revision 4 --command-id stop-turn-1",
+                run: [turn, "runTurnInterrupt"],
+            },
+        ],
+        [
+            "session approval list [--session <session-id>] [--all] [--limit <1..50>]",
+            1,
+            "approval.list",
+            "List what workers wait on a person for.",
+            {
+                example: "maia --json session approval list --all",
+                run: [approval, "runApprovalList"],
+            },
+        ],
+        [
+            "session approval show <approval-id>",
+            1,
+            "approval.show",
+            "Show one approval request.",
+            { run: [approval, "runApprovalShow"] },
+        ],
+        [
+            "session approval approve <approval-id> [--for-session] [--command-id <id>]",
+            1,
+            "approval.respond",
+            "Approve a worker's request.",
+            {
+                example: "maia session approval approve approval_1 --command-id approve-1",
+                kind: "discriminant",
+                run: [approval, "runApprovalApprove"],
+            },
+        ],
+        [
+            "session approval deny <approval-id> [--reason <text>] [--command-id <id>]",
+            1,
+            "approval.respond",
+            "Deny a worker's request.",
+            { kind: "discriminant", run: [approval, "runApprovalDeny"] },
+        ],
+        [
+            "session approval answer <approval-id> (--text <answer> | --option <option-id>) [--command-id <id>]",
+            1,
+            "approval.respond",
+            "Answer a worker's question.",
+            { kind: "discriminant", run: [approval, "runApprovalAnswer"] },
+        ],
+        [
+            "session interaction create --input-stdin",
+            1,
+            "interaction.create",
+            "Ask a person a question for an idle Session.",
+            { run: [interaction, "runInteractionCreate"] },
+        ],
+        [
+            "session interaction list --session <session-id> --project <project-id> [--status <pending|answered|cancelled|expired>] [--limit <1..100>] [--after <cursor>]",
+            1,
+            "interaction.list",
+            "List a Session's questions.",
+            { run: [interaction, "runInteractionList"] },
+        ],
+        [
+            "session interaction show <interaction-id>",
+            1,
+            "interaction.show",
+            "Show one question.",
+            { run: [interaction, "runInteractionShow"] },
+        ],
+        [
+            "session interaction respond --input-stdin",
+            1,
+            "interaction.respond",
+            "Record an answer to a question.",
+            { run: [interaction, "runInteractionRespond"] },
+        ],
+        [
+            "session interaction cancel --input-stdin",
+            1,
+            "interaction.cancel",
+            "Cancel a question.",
+            { run: [interaction, "runInteractionCancel"] },
+        ],
+        [
+            "import scan [--source claude,codex] [--since <days>d] [--root <path>] [--include-content] [--limit <1..100>] [--after <cursor>]",
+            1,
+            "discovery.sessions.list",
+            "Find Claude Code and Codex sessions to adopt.",
+            {
+                example: "maia --json import scan --source codex --since 7d",
+                run: [discovery, "runScan"],
+            },
+        ],
+    ],
+};
+//# sourceMappingURL=tree.js.map

package/dist/session/turn/client.d.ts

@@ -0,0 +1,25 @@
+import type { TurnInterruptResult, TurnSendResult, TurnShowResult, TurnWaitParameters, TurnWaitResult } from "@maiaos/sdk";
+import { type CliNodeEffect, type CliNodeOperations } from "../../local-node/index.js";
+export type InterruptTurnInput = {
+    readonly commandId?: string;
+    readonly expectedRevision: string;
+    readonly turnId: string;
+};
+export type SendTurnInput = {
+    readonly commandId?: string;
+    readonly expectedRevision: string;
+    readonly prompt: string;
+    readonly sessionId: string;
+};
+export type WaitTurnsInput = {
+    readonly mode: TurnWaitParameters["mode"];
+    readonly timeoutMilliseconds: number;
+    readonly turnIds: readonly string[];
+};
+export declare const makeTurnClient: (node: CliNodeOperations) => {
+    interruptTurn: (input: InterruptTurnInput) => CliNodeEffect<TurnInterruptResult>;
+    sendTurn: (input: SendTurnInput) => CliNodeEffect<TurnSendResult>;
+    showTurn: (turnId: string) => CliNodeEffect<TurnShowResult>;
+    waitTurns: (input: WaitTurnsInput) => CliNodeEffect<TurnWaitResult>;
+};
+//# sourceMappingURL=client.d.ts.map

package/dist/session/turn/client.js

@@ -0,0 +1,40 @@
+import { MAX_TURN_WAIT_MILLISECONDS, turnInterruptParametersSchema, turnSendParametersSchema, turnShowParametersSchema, turnWaitParametersSchema, } from "@maiaos/sdk";
+import { Effect } from "effect";
+import { commandIdentifier, } from "../../local-node/index.js";
+export const makeTurnClient = (node) => {
+    const interruptTurn = (input) => {
+        return Effect.flatMap(commandIdentifier(input.commandId), (commandId) => {
+            return node.runValidatedNodeOperation({
+                commandId,
+                expectedRevision: input.expectedRevision,
+                turnId: input.turnId,
+            }, turnInterruptParametersSchema, (client, parameters, options) => client.interruptTurn(parameters, options), { commandId });
+        });
+    };
+    const sendTurn = (input) => {
+        return Effect.flatMap(commandIdentifier(input.commandId), (commandId) => {
+            return node.runValidatedNodeOperation({
+                commandId,
+                expectedRevision: input.expectedRevision,
+                input: { text: input.prompt, type: "text" },
+                sessionId: input.sessionId,
+            }, turnSendParametersSchema, (client, parameters, options) => client.sendTurn(parameters, options), { commandId });
+        });
+    };
+    const showTurn = (turnId) => node.runValidatedNodeOperation({ turnId }, turnShowParametersSchema, (client, parameters, options) => client.showTurn(parameters, options));
+    const waitTurnsOnce = (parameters) => node.runValidatedNodeOperation(parameters, turnWaitParametersSchema, (client, validated, options) => client.waitTurns(validated, options));
+    const waitWithin = (input) => Effect.gen(function* () {
+        const waitMilliseconds = Math.min(MAX_TURN_WAIT_MILLISECONDS, input.timeoutMilliseconds);
+        const result = yield* waitTurnsOnce({
+            mode: input.mode,
+            turnIds: input.turnIds,
+            waitMilliseconds,
+        });
+        const remaining = input.timeoutMilliseconds - waitMilliseconds;
+        if (!result.ok || result.value.satisfied || remaining <= 0)
+            return result;
+        return yield* waitWithin({ ...input, timeoutMilliseconds: remaining });
+    });
+    return { interruptTurn, sendTurn, showTurn, waitTurns: waitWithin };
+};
+//# sourceMappingURL=client.js.map

package/dist/session/turn/commands.d.ts

@@ -0,0 +1,6 @@
+import { type CommandContext, type CommandEffect } from "../../command-line/index.js";
+export declare const runTurnSend: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runTurnInterrupt: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runTurnShow: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runTurnWait: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+//# sourceMappingURL=commands.d.ts.map

package/dist/session/turn/commands.js

@@ -0,0 +1,157 @@
+import { MAX_TURN_INPUT_BYTES, MAX_TURN_WAIT_IDS, } from "@maiaos/sdk";
+import * as Effect from "effect/Effect";
+import { CliArgumentError, parseOptions, readDuration, readExpectedRevision, readRevisionOption, requirePositionals, writeNodeResult, } from "../../command-line/index.js";
+import { formatTurnMutation, formatTurnShow, formatTurnWait, turnWaitExitCode, } from "./output.js";
+const utf8 = new TextEncoder();
+const summarizeTurnMutation = (result) => ({
+    delivery: result.delivery,
+    receipt: result.receipt,
+    revision: result.turn.revision,
+    sessionId: result.turn.sessionId,
+    state: result.turn.state,
+    turnId: result.turn.id,
+});
+const parseTurnSendArguments = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--command-id", "--expected-revision", "--session"]), new Set(["--prompt-stdin"]));
+    requirePositionals(parsed.positionals, 0);
+    const sessionId = parsed.options.get("--session");
+    if (sessionId === undefined) {
+        throw new CliArgumentError("Option '--session' is required.");
+    }
+    if (!parsed.flags.has("--prompt-stdin")) {
+        throw new CliArgumentError("Option '--prompt-stdin' is required.");
+    }
+    const commandId = parsed.options.get("--command-id");
+    return {
+        expectedRevision: readExpectedRevision(parsed.options.get("--expected-revision")),
+        sessionId,
+        ...(commandId === undefined ? {} : { commandId }),
+    };
+};
+export const runTurnSend = (tokens, context) => Effect.gen(function* () {
+    const input = parseTurnSendArguments(tokens);
+    if (context.io.stdin === undefined) {
+        throw new CliArgumentError("Standard input is unavailable.");
+    }
+    const prompt = yield* context.io.stdin({
+        label: "turn prompt",
+        maxBytes: MAX_TURN_INPUT_BYTES,
+        maxChunks: 1024,
+    });
+    const result = yield* context.dependencies.sendTurn({ ...input, prompt });
+    return writeNodeResult(result, context, {
+        toResult: (value) => ({
+            command: "turn.send",
+            result: summarizeTurnMutation(value),
+        }),
+        toText: formatTurnMutation,
+    });
+});
+const parseTurnInterruptArguments = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--command-id", "--expected-session-revision"]));
+    requirePositionals(parsed.positionals, 1);
+    const turnId = parsed.positionals[0];
+    if (turnId === undefined) {
+        throw new CliArgumentError("The turn identifier is missing.");
+    }
+    const commandId = parsed.options.get("--command-id");
+    return {
+        expectedRevision: readRevisionOption(parsed.options.get("--expected-session-revision"), "--expected-session-revision"),
+        turnId,
+        ...(commandId === undefined ? {} : { commandId }),
+    };
+};
+export const runTurnInterrupt = (tokens, context) => Effect.gen(function* () {
+    const input = parseTurnInterruptArguments(tokens);
+    const result = yield* context.dependencies.interruptTurn(input);
+    return writeNodeResult(result, context, {
+        toResult: (value) => ({
+            command: "turn.interrupt",
+            result: summarizeTurnMutation(value),
+        }),
+        toText: formatTurnMutation,
+    });
+});
+const parseTurnShowArguments = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(), new Set(["--include-content"]));
+    requirePositionals(parsed.positionals, 1);
+    const includeContent = parsed.flags.has("--include-content");
+    const turnId = parsed.positionals[0];
+    if (turnId === undefined) {
+        throw new CliArgumentError("The turn identifier is missing.");
+    }
+    return { includeContent, turnId };
+};
+const turnTerminalProjection = (turn) => {
+    if (turn.state === "completed") {
+        return {
+            responseBytes: utf8.encode(turn.responseText).byteLength,
+            ...(turn.tokenUsage === undefined ? {} : { tokenUsage: turn.tokenUsage }),
+        };
+    }
+    return turn.state === "failed" || turn.state === "outcome-unknown"
+        ? {
+            ...(turn.failure === undefined ? {} : { failure: turn.failure }),
+            failureReason: turn.failureReason,
+        }
+        : {};
+};
+const projectTurnWithoutContent = (value) => ({
+    contentIncluded: false,
+    method: value.method,
+    turn: {
+        id: value.turn.id,
+        inputBytes: utf8.encode(value.turn.input.text).byteLength,
+        revision: value.turn.revision,
+        sessionId: value.turn.sessionId,
+        sessionRevision: value.turn.sessionRevision,
+        state: value.turn.state,
+        ...turnTerminalProjection(value.turn),
+    },
+});
+const summarizeTurnShow = (value, includeContent) => includeContent
+    ? { ...value, contentIncluded: true }
+    : projectTurnWithoutContent(value);
+export const runTurnShow = (tokens, context) => Effect.gen(function* () {
+    const input = parseTurnShowArguments(tokens);
+    const result = yield* context.dependencies.showTurn(input.turnId);
+    return writeNodeResult(result, context, {
+        toResult: (value) => ({
+            command: "turn.show",
+            result: summarizeTurnShow(value, input.includeContent),
+        }),
+        toText: formatTurnShow,
+    });
+});
+const DEFAULT_TURN_WAIT_SECONDS = 600;
+const MAX_TURN_WAIT_SECONDS = 86_400;
+const readWaitTimeoutSeconds = (value) => value === undefined
+    ? DEFAULT_TURN_WAIT_SECONDS
+    : readDuration(value, "--timeout", { max: MAX_TURN_WAIT_SECONDS, min: 1 });
+const parseTurnWaitArguments = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--timeout"]), new Set(["--any"]));
+    if (parsed.positionals.length === 0 ||
+        parsed.positionals.length > MAX_TURN_WAIT_IDS)
+        throw new CliArgumentError(`Wait for 1 to ${String(MAX_TURN_WAIT_IDS)} turns.`);
+    return {
+        mode: parsed.flags.has("--any") ? "any" : "all",
+        timeoutMilliseconds: readWaitTimeoutSeconds(parsed.options.get("--timeout")) * 1000,
+        turnIds: parsed.positionals,
+    };
+};
+export const runTurnWait = (tokens, context) => Effect.gen(function* () {
+    const input = parseTurnWaitArguments(tokens);
+    const { waitTurns } = context.dependencies;
+    if (waitTurns === undefined)
+        throw new CliArgumentError("Turn wait is unavailable.");
+    const result = yield* waitTurns(input);
+    const code = writeNodeResult(result, context, {
+        toResult: (value) => ({
+            command: "turn.wait",
+            result: value,
+        }),
+        toText: formatTurnWait,
+    });
+    return result.ok ? turnWaitExitCode(result.value) : code;
+});
+//# sourceMappingURL=commands.js.map

package/dist/session/turn/index.d.ts

@@ -0,0 +1,4 @@
+export { type InterruptTurnInput, makeTurnClient, type SendTurnInput, type WaitTurnsInput, } from "./client.js";
+export { runTurnInterrupt, runTurnSend, runTurnShow, runTurnWait, } from "./commands.js";
+export { type CliTurnMutation, type CliTurnShow, type CliTurnWait, } from "./output.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/session/turn/index.js

@@ -0,0 +1,3 @@
+export { makeTurnClient, } from "./client.js";
+export { runTurnInterrupt, runTurnSend, runTurnShow, runTurnWait, } from "./commands.js";
+//# sourceMappingURL=index.js.map

package/dist/session/turn/output.d.ts

@@ -0,0 +1,42 @@
+import type { FailureDetail, TurnInterruptResult, TurnShowResult, TurnTokenUsage, TurnWaitResult } from "@maiaos/sdk";
+export type CliTurnMutation = {
+    readonly command: "turn.interrupt" | "turn.send";
+    readonly result: {
+        readonly delivery: TurnInterruptResult["delivery"];
+        readonly receipt: TurnInterruptResult["receipt"];
+        readonly revision: string;
+        readonly sessionId: string;
+        readonly state: TurnInterruptResult["turn"]["state"];
+        readonly turnId: string;
+    };
+};
+export type CliTurnShow = {
+    readonly command: "turn.show";
+    readonly result: (TurnShowResult & {
+        readonly contentIncluded: true;
+    }) | {
+        readonly contentIncluded: false;
+        readonly method: "turn.show";
+        readonly turn: {
+            readonly failure?: FailureDetail;
+            readonly failureReason?: string;
+            readonly id: string;
+            readonly inputBytes: number;
+            readonly responseBytes?: number;
+            readonly revision: string;
+            readonly sessionId: string;
+            readonly sessionRevision: string;
+            readonly state: TurnShowResult["turn"]["state"];
+            readonly tokenUsage?: TurnTokenUsage;
+        };
+    };
+};
+export type CliTurnWait = {
+    readonly command: "turn.wait";
+    readonly result: TurnWaitResult;
+};
+export declare const formatTurnMutation: ({ result }: CliTurnMutation) => string;
+export declare const formatTurnShow: ({ result }: CliTurnShow) => string;
+export declare const formatTurnWait: ({ result }: CliTurnWait) => string;
+export declare const turnWaitExitCode: (result: TurnWaitResult) => number;
+//# sourceMappingURL=output.d.ts.map

package/dist/session/turn/output.js

@@ -0,0 +1,38 @@
+import { formatFailure } from "../output/index.js";
+const tab = (values) => values.join("\t");
+const printable = (text) => Array.from(text, (character) => {
+    const point = character.codePointAt(0) ?? 0;
+    return (point < 32 && character !== "\n" && character !== "\t") ||
+        (point >= 127 && point <= 159)
+        ? "�"
+        : character;
+}).join("");
+export const formatTurnMutation = ({ result }) => `${result.turnId}\t${result.state}\t${result.revision}\n`;
+const formatUsage = (usage) => usage === undefined
+    ? ""
+    : `tokens: input ${String(usage.inputTokens)} (cached ${String(usage.cachedInputTokens)}), output ${String(usage.outputTokens)} (reasoning ${String(usage.reasoningOutputTokens)}), total ${String(usage.totalTokens)}${usage.modelCallCount === undefined ? "" : `, model calls ${String(usage.modelCallCount)}`}\n`;
+const formatContent = (turn) => `input:\n${printable(turn.input.text)}\n${turn.state === "completed" ? `response:\n${printable(turn.responseText)}\n` : ""}`;
+const shownContent = (result) => result.contentIncluded ? formatContent(result.turn) : "";
+export const formatTurnShow = ({ result }) => {
+    const { turn } = result;
+    const failure = "failure" in turn &&
+        (turn.state === "failed" || turn.state === "outcome-unknown")
+        ? formatFailure(turn.failure, turn.state)
+        : "";
+    const usage = "tokenUsage" in turn ? formatUsage(turn.tokenUsage) : "";
+    return `${tab([turn.id, turn.state, turn.revision, turn.sessionId])}\n${failure}${usage}${shownContent(result)}`;
+};
+export const formatTurnWait = ({ result }) => result.turns
+    .map((turn) => `${tab([turn.id, turn.state, turn.revision, turn.sessionId, ...(turn.failureReason === undefined ? [] : [turn.failureReason])])}\n${turn.state === "failed" || turn.state === "outcome-unknown" ? formatFailure(turn.failure, turn.state) : ""}`)
+    .join("");
+const EXIT_FAILED = 70;
+const EXIT_DEADLINE = 74;
+const EXIT_OUTCOME_UNKNOWN = 76;
+export const turnWaitExitCode = (result) => {
+    if (!result.satisfied)
+        return EXIT_DEADLINE;
+    if (result.turns.some((turn) => turn.state === "outcome-unknown"))
+        return EXIT_OUTCOME_UNKNOWN;
+    return result.turns.some((turn) => turn.state === "failed") ? EXIT_FAILED : 0;
+};
+//# sourceMappingURL=output.js.map