voratiq 0.1.0-beta.20 → 0.1.0-beta.21

package/dist/agents/runtime/policy.d.ts

@@ -1,6 +1,6 @@
 import type { SandboxFilesystemConfig, SandboxNetworkConfig } from "../../configs/sandbox/types.js";
 import type { SandboxPolicyOverrides } from "./types.js";
-export type SandboxStageId = "run" | "spec" | "verify" | "reduce";
+export type SandboxStageId = "spec" | "run" | "reduce" | "verify" | "message";
 export interface BuildSandboxPolicyInput {
     stageId: SandboxStageId;
     root: string;

package/dist/bin.js

@@ -65,6 +65,13 @@ async function handleSignal(signal) {
     process.exit(exitCode);
 }
 async function flushPendingHistory() {
+    try {
+        const { flushAllSpecRecordBuffers } = await import("./domain/spec/persistence/adapter.js");
+        await flushAllSpecRecordBuffers();
+    }
+    catch (error) {
+        console.warn(`[voratiq] Failed to flush spec history buffers: ${error.message}`);
+    }
     try {
         const { flushAllRunRecordBuffers } = await import("./domain/run/persistence/adapter.js");
         await flushAllRunRecordBuffers();
@@ -73,32 +80,32 @@ async function flushPendingHistory() {
         console.warn(`[voratiq] Failed to flush run history buffers: ${error.message}`);
     }
     try {
-        const { flushAllVerificationRecordBuffers } = await import("./domain/verify/persistence/adapter.js");
-        await flushAllVerificationRecordBuffers();
+        const { flushAllReductionRecordBuffers } = await import("./domain/reduce/persistence/adapter.js");
+        await flushAllReductionRecordBuffers();
     }
     catch (error) {
-        console.warn(`[voratiq] Failed to flush verification history buffers: ${error.message}`);
+        console.warn(`[voratiq] Failed to flush reduction history buffers: ${error.message}`);
     }
     try {
-        const { flushAllInteractiveSessionBuffers } = await import("./domain/interactive/persistence/adapter.js");
-        await flushAllInteractiveSessionBuffers();
+        const { flushAllVerificationRecordBuffers } = await import("./domain/verify/persistence/adapter.js");
+        await flushAllVerificationRecordBuffers();
     }
     catch (error) {
-        console.warn(`[voratiq] Failed to flush interactive history buffers: ${error.message}`);
+        console.warn(`[voratiq] Failed to flush verification history buffers: ${error.message}`);
     }
     try {
-        const { flushAllSpecRecordBuffers } = await import("./domain/spec/persistence/adapter.js");
-        await flushAllSpecRecordBuffers();
+        const { flushAllMessageRecordBuffers } = await import("./domain/message/persistence/adapter.js");
+        await flushAllMessageRecordBuffers();
     }
     catch (error) {
-        console.warn(`[voratiq] Failed to flush spec history buffers: ${error.message}`);
+        console.warn(`[voratiq] Failed to flush message history buffers: ${error.message}`);
     }
     try {
-        const { flushAllReductionRecordBuffers } = await import("./domain/reduce/persistence/adapter.js");
-        await flushAllReductionRecordBuffers();
+        const { flushAllInteractiveSessionBuffers } = await import("./domain/interactive/persistence/adapter.js");
+        await flushAllInteractiveSessionBuffers();
     }
     catch (error) {
-        console.warn(`[voratiq] Failed to flush reduction history buffers: ${error.message}`);
+        console.warn(`[voratiq] Failed to flush interactive history buffers: ${error.message}`);
     }
 }
 async function terminateActiveRunSafe(status, context) {
@@ -140,11 +147,30 @@ async function terminateActiveInteractiveSafe(status, context) {
         return normalizedError;
     }
 }
+async function terminateActiveMessageSafe(status, context) {
+    try {
+        const { terminateActiveMessage } = await import("./commands/message/lifecycle.js");
+        await terminateActiveMessage(status);
+        return null;
+    }
+    catch (error) {
+        const { toErrorMessage } = await import("./utils/errors.js");
+        const normalizedError = error instanceof Error ? error : new Error(toErrorMessage(error));
+        console.error(`[voratiq] Failed to teardown message after ${context}: ${toErrorMessage(error)}`);
+        return normalizedError;
+    }
+}
 async function terminateActiveSessionsSafe(status, context) {
     const runError = await terminateActiveRunSafe(status, context);
     const verificationError = await terminateActiveVerificationSafe(status, context);
     const interactiveError = await terminateActiveInteractiveSafe(status, context);
-    const errors = [runError, verificationError, interactiveError].filter((error) => error instanceof Error);
+    const messageError = await terminateActiveMessageSafe(status, context);
+    const errors = [
+        runError,
+        verificationError,
+        interactiveError,
+        messageError,
+    ].filter((error) => error instanceof Error);
     if (errors.length > 1) {
         return new AggregateError(errors, `Failed to teardown active sessions after ${context}`);
     }
@@ -304,12 +330,13 @@ async function registerCommands(program, argv) {
     const wantsHelp = argv.includes("--help") || argv.includes("-h");
     const wantsVersion = argv.includes("--version") || argv.includes("-v");
     const knownCommandNames = new Set([
-        "auto",
         "init",
         "spec",
         "run",
-        "verify",
         "reduce",
+        "verify",
+        "message",
+        "auto",
         "apply",
         "list",
         "prune",
@@ -322,12 +349,13 @@ async function registerCommands(program, argv) {
         return;
     }
     if (loadAll) {
-        program.addCommand((await import("./cli/auto.js")).createAutoCommand());
         program.addCommand((await import("./cli/init.js")).createInitCommand());
         program.addCommand((await import("./cli/spec.js")).createSpecCommand());
         program.addCommand((await import("./cli/run.js")).createRunCommand());
         program.addCommand((await import("./cli/reduce.js")).createReduceCommand());
         program.addCommand((await import("./cli/verify.js")).createVerifyCommand());
+        program.addCommand((await import("./cli/message.js")).createMessageCommand());
+        program.addCommand((await import("./cli/auto.js")).createAutoCommand());
         program.addCommand((await import("./cli/apply.js")).createApplyCommand());
         program.addCommand((await import("./cli/list.js")).createListCommand());
         program.addCommand((await import("./cli/prune.js")).createPruneCommand());
@@ -338,9 +366,6 @@ async function registerCommands(program, argv) {
         case "init":
             program.addCommand((await import("./cli/init.js")).createInitCommand());
             break;
-        case "list":
-            program.addCommand((await import("./cli/list.js")).createListCommand());
-            break;
         case "spec":
             program.addCommand((await import("./cli/spec.js")).createSpecCommand());
             break;
@@ -353,12 +378,18 @@ async function registerCommands(program, argv) {
         case "verify":
             program.addCommand((await import("./cli/verify.js")).createVerifyCommand());
             break;
+        case "message":
+            program.addCommand((await import("./cli/message.js")).createMessageCommand());
+            break;
         case "auto":
             program.addCommand((await import("./cli/auto.js")).createAutoCommand());
             break;
         case "apply":
             program.addCommand((await import("./cli/apply.js")).createApplyCommand());
             break;
+        case "list":
+            program.addCommand((await import("./cli/list.js")).createListCommand());
+            break;
         case "prune":
             program.addCommand((await import("./cli/prune.js")).createPruneCommand());
             break;

package/dist/cli/contract.d.ts

@@ -1,13 +1,14 @@
 import { type Command } from "commander";
 import { z } from "zod";
 import { type ListMode, type ListOperator } from "../contracts/list.js";
-export declare const externalExecutionOperators: readonly ["spec", "run", "reduce", "verify", "apply", "prune"];
-export declare const externalInspectionOperators: readonly ["spec", "run", "reduce", "verify"];
+export declare const externalExecutionOperators: readonly ["spec", "run", "reduce", "verify", "message", "apply", "prune"];
+export declare const externalInspectionOperators: readonly ["spec", "run", "reduce", "verify", "message"];
 export declare const externalInspectionModes: readonly ["table", "detail"];
 export type ExternalExecutionOperator = (typeof externalExecutionOperators)[number];
 export type ExternalInspectionOperator = ListOperator;
 export type ExternalInspectionMode = ListMode;
 export declare const externalExecutionOperatorSchema: z.ZodEnum<{
+    message: "message";
     reduce: "reduce";
     apply: "apply";
     spec: "spec";
@@ -16,6 +17,7 @@ export declare const externalExecutionOperatorSchema: z.ZodEnum<{
     prune: "prune";
 }>;
 export declare const externalInspectionOperatorSchema: z.ZodEnum<{
+    message: "message";
     reduce: "reduce";
     spec: "spec";
     run: "run";
@@ -44,6 +46,7 @@ export declare const externalRunExecutionInputSchema: z.ZodObject<{
 export declare const externalReduceExecutionInputSchema: z.ZodObject<{
     target: z.ZodObject<{
         type: z.ZodEnum<{
+            message: "message";
             reduce: "reduce";
             spec: "spec";
             run: "run";
@@ -56,9 +59,17 @@ export declare const externalReduceExecutionInputSchema: z.ZodObject<{
     maxParallel: z.ZodOptional<z.ZodNumber>;
     extraContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
+export declare const externalMessageExecutionInputSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    agentIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    profile: z.ZodOptional<z.ZodString>;
+    maxParallel: z.ZodOptional<z.ZodNumber>;
+    extraContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
 export declare const externalVerifyExecutionInputSchema: z.ZodObject<{
     target: z.ZodObject<{
         kind: z.ZodEnum<{
+            message: "message";
             reduce: "reduce";
             spec: "spec";
             run: "run";
@@ -88,6 +99,7 @@ export declare const externalPruneExecutionInputSchema: z.ZodDiscriminatedUnion<
 }, z.core.$strict>], "scope">;
 export declare const externalListTableInputSchema: z.ZodObject<{
     operator: z.ZodEnum<{
+        message: "message";
         reduce: "reduce";
         spec: "spec";
         run: "run";
@@ -99,6 +111,7 @@ export declare const externalListTableInputSchema: z.ZodObject<{
 }, z.core.$strict>;
 export declare const externalListDetailInputSchema: z.ZodObject<{
     operator: z.ZodEnum<{
+        message: "message";
         reduce: "reduce";
         spec: "spec";
         run: "run";
@@ -111,6 +124,7 @@ export declare const externalListDetailInputSchema: z.ZodObject<{
 }, z.core.$strict>;
 export declare const externalListInspectionInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     operator: z.ZodEnum<{
+        message: "message";
         reduce: "reduce";
         spec: "spec";
         run: "run";
@@ -121,6 +135,7 @@ export declare const externalListInspectionInputSchema: z.ZodDiscriminatedUnion<
     mode: z.ZodLiteral<"table">;
 }, z.core.$strict>, z.ZodObject<{
     operator: z.ZodEnum<{
+        message: "message";
         reduce: "reduce";
         spec: "spec";
         run: "run";
@@ -151,6 +166,7 @@ export declare const externalExecutionInputSchemas: {
     readonly reduce: z.ZodObject<{
         target: z.ZodObject<{
             type: z.ZodEnum<{
+                message: "message";
                 reduce: "reduce";
                 spec: "spec";
                 run: "run";
@@ -166,6 +182,7 @@ export declare const externalExecutionInputSchemas: {
     readonly verify: z.ZodObject<{
         target: z.ZodObject<{
             kind: z.ZodEnum<{
+                message: "message";
                 reduce: "reduce";
                 spec: "spec";
                 run: "run";
@@ -177,6 +194,13 @@ export declare const externalExecutionInputSchemas: {
         maxParallel: z.ZodOptional<z.ZodNumber>;
         extraContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>;
+    readonly message: z.ZodObject<{
+        prompt: z.ZodString;
+        agentIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        profile: z.ZodOptional<z.ZodString>;
+        maxParallel: z.ZodOptional<z.ZodNumber>;
+        extraContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
     readonly apply: z.ZodObject<{
         runId: z.ZodString;
         agentId: z.ZodString;
@@ -198,6 +222,7 @@ export declare const externalInspectionInputSchemas: {
     readonly list: {
         readonly table: z.ZodObject<{
             operator: z.ZodEnum<{
+                message: "message";
                 reduce: "reduce";
                 spec: "spec";
                 run: "run";
@@ -209,6 +234,7 @@ export declare const externalInspectionInputSchemas: {
         }, z.core.$strict>;
         readonly detail: z.ZodObject<{
             operator: z.ZodEnum<{
+                message: "message";
                 reduce: "reduce";
                 spec: "spec";
                 run: "run";
@@ -221,6 +247,7 @@ export declare const externalInspectionInputSchemas: {
         }, z.core.$strict>;
         readonly union: z.ZodDiscriminatedUnion<[z.ZodObject<{
             operator: z.ZodEnum<{
+                message: "message";
                 reduce: "reduce";
                 spec: "spec";
                 run: "run";
@@ -231,6 +258,7 @@ export declare const externalInspectionInputSchemas: {
             mode: z.ZodLiteral<"table">;
         }, z.core.$strict>, z.ZodObject<{
             operator: z.ZodEnum<{
+                message: "message";
                 reduce: "reduce";
                 spec: "spec";
                 run: "run";
@@ -246,13 +274,14 @@ export declare const externalInspectionInputSchemas: {
 export type ExternalSpecExecutionInput = z.infer<typeof externalSpecExecutionInputSchema>;
 export type ExternalRunExecutionInput = z.infer<typeof externalRunExecutionInputSchema>;
 export type ExternalReduceExecutionInput = z.infer<typeof externalReduceExecutionInputSchema>;
+export type ExternalMessageExecutionInput = z.infer<typeof externalMessageExecutionInputSchema>;
 export type ExternalVerifyExecutionInput = z.infer<typeof externalVerifyExecutionInputSchema>;
 export type ExternalApplyExecutionInput = z.infer<typeof externalApplyExecutionInputSchema>;
 export type ExternalPruneExecutionInput = z.infer<typeof externalPruneExecutionInputSchema>;
 export type ExternalListInspectionInput = z.infer<typeof externalListInspectionInputSchema>;
 export declare const externalAdapterContractReference: {
     readonly execution: {
-        readonly operators: readonly ["spec", "run", "reduce", "verify", "apply", "prune"];
+        readonly operators: readonly ["spec", "run", "reduce", "verify", "message", "apply", "prune"];
         readonly envelope: {
             readonly authoritativeType: "OperatorResultEnvelope";
             readonly versioned: true;
@@ -262,12 +291,12 @@ export declare const externalAdapterContractReference: {
     readonly inspection: {
         readonly command: "list";
         readonly jsonOnly: true;
-        readonly operators: readonly ["spec", "run", "reduce", "verify"];
+        readonly operators: readonly ["spec", "run", "reduce", "verify", "message"];
         readonly modes: readonly ["table", "detail"];
         readonly authoritativeType: "ListJsonOutput";
         readonly versioned: false;
     };
-    readonly excludedCommands: readonly ["auto", "init"];
+    readonly excludedCommands: readonly ["init", "auto"];
     readonly compatibility: {
         readonly additiveChangesAreNonBreaking: true;
         readonly breakingChangesRequireExecutionEnvelopeVersionBump: true;
@@ -291,6 +320,7 @@ export interface PruneCommandSelection {
 export declare function parseSpecExecutionCommandOptions(options: unknown, command: Command): ExternalSpecExecutionInput;
 export declare function parseRunExecutionCommandOptions(options: unknown, command: Command): ExternalRunExecutionInput;
 export declare function parseReduceExecutionCommandOptions(options: unknown, command: Command): ExternalReduceExecutionInput;
+export declare function parseMessageExecutionCommandOptions(options: unknown, command: Command): ExternalMessageExecutionInput;
 export declare function parseVerifyExecutionCommandOptions(options: unknown, command: Command): ExternalVerifyExecutionInput;
 export declare function parseApplyExecutionCommandOptions(options: unknown, command: Command): ExternalApplyExecutionInput;
 export declare function parseExternalPruneExecutionInput(input: unknown): ExternalPruneExecutionInput;

package/dist/cli/contract.js

@@ -14,6 +14,7 @@ export const externalExecutionOperators = [
     "run",
     "reduce",
     "verify",
+    "message",
     "apply",
     "prune",
 ];
@@ -46,7 +47,7 @@ export const externalReduceExecutionInputSchema = z
     .object({
     target: z
         .object({
-        type: z.enum(["spec", "run", "verify", "reduce"]),
+        type: z.enum(["spec", "run", "reduce", "verify", "message"]),
         id: nonEmptyStringSchema,
     })
         .strict(),
@@ -56,11 +57,20 @@ export const externalReduceExecutionInputSchema = z
     extraContext: optionalNonEmptyStringArraySchema,
 })
     .strict();
+export const externalMessageExecutionInputSchema = z
+    .object({
+    prompt: nonEmptyStringSchema,
+    agentIds: optionalNonEmptyStringArraySchema,
+    profile: nonEmptyStringSchema.optional(),
+    maxParallel: positiveIntegerSchema.optional(),
+    extraContext: optionalNonEmptyStringArraySchema,
+})
+    .strict();
 export const externalVerifyExecutionInputSchema = z
     .object({
     target: z
         .object({
-        kind: z.enum(["spec", "run", "reduce"]),
+        kind: z.enum(["spec", "run", "reduce", "message"]),
         sessionId: nonEmptyStringSchema,
     })
         .strict(),
@@ -116,6 +126,7 @@ export const externalExecutionInputSchemas = {
     run: externalRunExecutionInputSchema,
     reduce: externalReduceExecutionInputSchema,
     verify: externalVerifyExecutionInputSchema,
+    message: externalMessageExecutionInputSchema,
     apply: externalApplyExecutionInputSchema,
     prune: externalPruneExecutionInputSchema,
 };
@@ -143,7 +154,7 @@ export const externalAdapterContractReference = {
         authoritativeType: "ListJsonOutput",
         versioned: false,
     },
-    excludedCommands: ["auto", "init"],
+    excludedCommands: ["init", "auto"],
     compatibility: {
         additiveChangesAreNonBreaking: true,
         breakingChangesRequireExecutionEnvelopeVersionBump: true,
@@ -189,8 +200,19 @@ const reduceCommandActionOptionsSchema = z
     .object({
     spec: nonEmptyStringSchema.optional(),
     run: nonEmptyStringSchema.optional(),
-    verify: nonEmptyStringSchema.optional(),
     reduce: nonEmptyStringSchema.optional(),
+    verify: nonEmptyStringSchema.optional(),
+    message: nonEmptyStringSchema.optional(),
+    agent: z.array(nonEmptyStringSchema).optional(),
+    profile: nonEmptyStringSchema.optional(),
+    maxParallel: positiveIntegerSchema.optional(),
+    extraContext: z.array(nonEmptyStringSchema).optional(),
+    json: z.boolean().optional(),
+})
+    .strict();
+const messageCommandActionOptionsSchema = z
+    .object({
+    prompt: nonEmptyStringSchema,
     agent: z.array(nonEmptyStringSchema).optional(),
     profile: nonEmptyStringSchema.optional(),
     maxParallel: positiveIntegerSchema.optional(),
@@ -203,6 +225,7 @@ const verifyCommandActionOptionsSchema = z
     spec: nonEmptyStringSchema.optional(),
     run: nonEmptyStringSchema.optional(),
     reduce: nonEmptyStringSchema.optional(),
+    message: nonEmptyStringSchema.optional(),
     agent: z.array(nonEmptyStringSchema).optional(),
     profile: nonEmptyStringSchema.optional(),
     maxParallel: positiveIntegerSchema.optional(),
@@ -225,6 +248,7 @@ const listCommandActionOptionsSchema = z
     run: z.union([z.literal(true), nonEmptyStringSchema]).optional(),
     reduce: z.union([z.literal(true), nonEmptyStringSchema]).optional(),
     verify: z.union([z.literal(true), nonEmptyStringSchema]).optional(),
+    message: z.union([z.literal(true), nonEmptyStringSchema]).optional(),
     limit: positiveIntegerSchema.optional(),
     verbose: z.boolean().optional(),
     json: z.boolean().optional(),
@@ -266,8 +290,9 @@ export function parseReduceExecutionCommandOptions(options, command) {
     const selected = resolveExclusiveStringSelection([
         { key: "spec", flag: "--spec", value: "spec" },
         { key: "run", flag: "--run", value: "run" },
-        { key: "verify", flag: "--verify", value: "verify" },
         { key: "reduce", flag: "--reduce", value: "reduce" },
+        { key: "verify", flag: "--verify", value: "verify" },
+        { key: "message", flag: "--message", value: "message" },
     ], parsed, command, "target flag");
     return parseCommandOptions(externalReduceExecutionInputSchema, {
         target: {
@@ -280,12 +305,23 @@ export function parseReduceExecutionCommandOptions(options, command) {
         extraContext: normalizeOptionalStringArray(parsed.extraContext),
     }, command);
 }
+export function parseMessageExecutionCommandOptions(options, command) {
+    const parsed = parseCommandOptions(messageCommandActionOptionsSchema, options, command);
+    return parseCommandOptions(externalMessageExecutionInputSchema, {
+        prompt: parsed.prompt,
+        agentIds: normalizeOptionalStringArray(parsed.agent),
+        profile: parsed.profile,
+        maxParallel: parsed.maxParallel,
+        extraContext: normalizeOptionalStringArray(parsed.extraContext),
+    }, command);
+}
 export function parseVerifyExecutionCommandOptions(options, command) {
     const parsed = parseCommandOptions(verifyCommandActionOptionsSchema, options, command);
     const selected = resolveExclusiveStringSelection([
         { key: "spec", flag: "--spec", value: "spec" },
         { key: "run", flag: "--run", value: "run" },
         { key: "reduce", flag: "--reduce", value: "reduce" },
+        { key: "message", flag: "--message", value: "message" },
     ], parsed, command, "target flag");
     return parseCommandOptions(externalVerifyExecutionInputSchema, {
         target: {
@@ -328,6 +364,7 @@ export function parseListInspectionCommandOptions(options, command) {
         { key: "run", flag: "--run", value: "run" },
         { key: "reduce", flag: "--reduce", value: "reduce" },
         { key: "verify", flag: "--verify", value: "verify" },
+        { key: "message", flag: "--message", value: "message" },
     ], parsed, command, "operator flag");
     return parseCommandOptions(externalListInspectionInputSchema, {
         operator: selected.value,

package/dist/cli/list.js

@@ -2,7 +2,7 @@ import { Command } from "commander";
 import { executeListCommand } from "../commands/list/command.js";
 import { resolveCliContext } from "../preflight/index.js";
 import { parsePositiveInteger } from "../utils/validators.js";
-import { resolveWorkspacePath, VORATIQ_REDUCTION_FILE, VORATIQ_VERIFICATION_FILE, } from "../workspace/structure.js";
+import { resolveWorkspacePath, VORATIQ_MESSAGE_FILE, VORATIQ_REDUCTION_FILE, VORATIQ_VERIFICATION_FILE, } from "../workspace/structure.js";
 import { parseListInspectionCommandOptions } from "./contract.js";
 import { writeCommandOutput } from "./output.js";
 export async function runListCommand(options) {
@@ -15,6 +15,8 @@ export async function runListCommand(options) {
         runsFilePath: workspacePaths.runsFile,
         reductionsFilePath: workspacePaths.reductionsFile ??
             resolveWorkspacePath(root, VORATIQ_REDUCTION_FILE),
+        messagesFilePath: workspacePaths.messagesFile ??
+            resolveWorkspacePath(root, VORATIQ_MESSAGE_FILE),
         verificationsFilePath: workspacePaths.verificationsFile ??
             resolveWorkspacePath(root, VORATIQ_VERIFICATION_FILE),
         operator: options.operator,
@@ -42,6 +44,7 @@ export function createListCommand() {
         .option("--run [session-id]", "List run sessions or show one run session")
         .option("--reduce [session-id]", "List reduction sessions or show one reduction session")
         .option("--verify [session-id]", "List verification sessions or show one verification session")
+        .option("--message [session-id]", "List message sessions or show one message session")
         .option("--limit <count>", "Show only the N most recent sessions (default: 10)", parseLimitOption)
         .option("--verbose", "Show all statuses for the selected operator in table mode")
         .option("--json", "Emit machine-readable list output")

package/dist/cli/message.d.ts

@@ -0,0 +1,28 @@
+import { Command } from "commander";
+import { type CommandOutputWriter } from "./output.js";
+export interface MessageCommandOptions {
+    prompt: string;
+    agentIds?: string[];
+    profile?: string;
+    maxParallel?: number;
+    extraContext?: string[];
+    json?: boolean;
+    stdout?: Pick<NodeJS.WriteStream, "write"> & {
+        isTTY?: boolean;
+    };
+    stderr?: Pick<NodeJS.WriteStream, "write"> & {
+        isTTY?: boolean;
+    };
+    writeOutput?: CommandOutputWriter;
+}
+export interface MessageCommandResult {
+    body: string;
+    sessionId: string;
+    status: "queued" | "running" | "succeeded" | "failed" | "aborted";
+    outputArtifacts: ReadonlyArray<{
+        agentId: string;
+        outputPath?: string;
+    }>;
+}
+export declare function runMessageCommand(options: MessageCommandOptions): Promise<MessageCommandResult>;
+export declare function createMessageCommand(): Command;