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

package/dist/cli/message.js

@@ -0,0 +1,147 @@
+import { readFile } from "node:fs/promises";
+import { Command, Option } from "commander";
+import { checkPlatformSupport } from "../agents/runtime/sandbox.js";
+import { executeMessageCommand } from "../commands/message/command.js";
+import { buildMarkdownPreviewLines } from "../commands/shared/preview.js";
+import { resolveExtraContextFiles } from "../competition/shared/extra-context.js";
+import { ensureSandboxDependencies, resolveCliContext, } from "../preflight/index.js";
+import { createMessageRenderer, formatMessageElapsed, formatMessageRecipientDuration, renderMessageTranscript, } from "../render/transcripts/message.js";
+import { renderWorkspaceAutoInitializedNotice } from "../render/transcripts/shared.js";
+import { createStageStartLineEmitter } from "../render/utils/stage-output.js";
+import { resolvePath } from "../utils/path.js";
+import { parsePositiveInteger } from "../utils/validators.js";
+import { resolveWorkspacePath, VORATIQ_MESSAGE_FILE, } from "../workspace/structure.js";
+import { parseMessageExecutionCommandOptions } from "./contract.js";
+import { buildMessageOperatorEnvelope, createSilentCliWriter, writeOperatorResultEnvelope, } from "./operator-envelope.js";
+import { writeCommandOutput } from "./output.js";
+export async function runMessageCommand(options) {
+    const { prompt, agentIds, profile, maxParallel, extraContext, json = false, stdout, stderr, writeOutput, } = options;
+    const effectiveWriteOutput = json
+        ? undefined
+        : (writeOutput ?? writeCommandOutput);
+    const rendererStdout = json ? createSilentCliWriter() : stdout;
+    const rendererStderr = json ? createSilentCliWriter() : stderr;
+    const isTty = json ? false : (stdout?.isTTY ?? process.stdout.isTTY);
+    const { root, workspacePaths, workspaceAutoInitialized } = await resolveCliContext({
+        workspaceAutoInitMode: "when-missing",
+    });
+    const workspaceNotice = workspaceAutoInitialized
+        ? renderWorkspaceAutoInitializedNotice()
+        : undefined;
+    if (workspaceNotice && effectiveWriteOutput) {
+        effectiveWriteOutput({
+            alerts: [{ severity: "info", message: workspaceNotice }],
+            leadingNewline: false,
+        });
+    }
+    checkPlatformSupport();
+    ensureSandboxDependencies();
+    const extraContextFiles = await resolveExtraContextFiles({
+        root,
+        paths: extraContext,
+    });
+    const startLine = createStageStartLineEmitter((message) => {
+        effectiveWriteOutput?.({
+            alerts: [{ severity: "info", message }],
+        });
+    });
+    if (effectiveWriteOutput) {
+        startLine.emit("Messaging…");
+    }
+    const renderer = createMessageRenderer({
+        stdout: rendererStdout,
+        stderr: rendererStderr,
+    });
+    const execution = await executeMessageCommand({
+        root,
+        messagesFilePath: workspacePaths.messagesFile ??
+            resolveWorkspacePath(root, VORATIQ_MESSAGE_FILE),
+        prompt,
+        agentIds,
+        profileName: profile,
+        maxParallel,
+        extraContextFiles,
+        sourceInteractiveSessionId: process.env.VORATIQ_INTERACTIVE_SESSION_ID?.trim() || undefined,
+        renderer,
+    });
+    const body = renderMessageTranscript({
+        messageId: execution.messageId,
+        createdAt: execution.record.createdAt,
+        elapsed: formatMessageElapsed({
+            status: execution.record.status,
+            startedAt: execution.record.startedAt,
+            completedAt: execution.record.completedAt,
+        }) ?? "—",
+        workspacePath: `.voratiq/message/sessions/${execution.messageId}`,
+        status: execution.record.status,
+        recipients: await Promise.all(execution.recipients.map(async (recipient) => ({
+            agentId: recipient.agentId,
+            status: recipient.status,
+            duration: formatMessageRecipientDuration({
+                status: recipient.status,
+                startedAt: recipient.startedAt,
+                completedAt: recipient.completedAt,
+            }) ?? "—",
+            outputPath: recipient.outputPath,
+            previewLines: recipient.status === "succeeded" && recipient.outputPath
+                ? buildMarkdownPreviewLines(await readFile(resolvePath(root, recipient.outputPath), "utf8"))
+                : undefined,
+            errorLine: recipient.error ?? undefined,
+        }))),
+        isTty,
+        includeSummarySection: !isTty,
+    });
+    return {
+        body,
+        sessionId: execution.messageId,
+        status: execution.record.status,
+        outputArtifacts: execution.recipients.map((recipient) => ({
+            agentId: recipient.agentId,
+            outputPath: recipient.outputPath,
+        })),
+    };
+}
+function collectStringOption(value, previous) {
+    return [...previous, value];
+}
+function parseMaxParallelOption(value) {
+    return parsePositiveInteger(value, "Expected positive integer after --max-parallel", "--max-parallel must be greater than 0");
+}
+export function createMessageCommand() {
+    return new Command("message")
+        .description("Send an isolated prompt to one or more agents")
+        .requiredOption("--prompt <text>", "Prompt to send")
+        .addOption(new Option("--agent <agent-id>", "Set recipient agents directly (repeatable; order preserved)")
+        .default([], "")
+        .argParser(collectStringOption))
+        .option("--profile <name>", 'Orchestration profile (default: "default")')
+        .option("--max-parallel <count>", "Max concurrent recipients (default: all)", parseMaxParallelOption)
+        .addOption(new Option("--extra-context <path>", "Stage an extra context file into each recipient workspace (repeatable)")
+        .default([], "")
+        .argParser(collectStringOption))
+        .option("--json", "Emit a machine-readable result envelope")
+        .allowExcessArguments(false)
+        .action(async (options, command) => {
+        const input = parseMessageExecutionCommandOptions(options, command);
+        const result = await runMessageCommand({
+            prompt: input.prompt,
+            agentIds: input.agentIds,
+            profile: input.profile,
+            maxParallel: input.maxParallel,
+            extraContext: input.extraContext,
+            json: Boolean(options.json),
+        });
+        if (options.json) {
+            writeOperatorResultEnvelope(buildMessageOperatorEnvelope({
+                sessionId: result.sessionId,
+                status: result.status,
+                outputArtifacts: result.outputArtifacts,
+            }), result.status === "succeeded" ? 0 : 1);
+            return;
+        }
+        writeCommandOutput({
+            body: result.body,
+            exitCode: result.status === "succeeded" ? 0 : 1,
+        });
+    });
+}

package/dist/cli/operator-envelope.d.ts

@@ -21,8 +21,13 @@ export interface OperatorResultEnvelope {
         runId?: string;
         verificationId?: string;
         reductionId?: string;
+        messageId?: string;
         agentId?: string;
     };
+    target?: {
+        kind: string;
+        sessionId: string;
+    };
     artifacts: EnvelopeArtifactRef[];
     selection?: {
         state: "resolvable" | "unresolved";
@@ -45,6 +50,7 @@ export interface OperatorResultEnvelope {
 export declare const operatorResultEnvelopeSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     operator: z.ZodEnum<{
+        message: "message";
         reduce: "reduce";
         apply: "apply";
         spec: "spec";
@@ -63,8 +69,13 @@ export declare const operatorResultEnvelopeSchema: z.ZodObject<{
         runId: z.ZodOptional<z.ZodString>;
         verificationId: z.ZodOptional<z.ZodString>;
         reductionId: z.ZodOptional<z.ZodString>;
+        messageId: z.ZodOptional<z.ZodString>;
         agentId: z.ZodOptional<z.ZodString>;
     }, z.core.$loose>>;
+    target: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodString;
+        sessionId: z.ZodString;
+    }, z.core.$loose>>;
     artifacts: z.ZodArray<z.ZodObject<{
         kind: z.ZodString;
         path: z.ZodString;
@@ -99,7 +110,7 @@ export declare const operatorResultEnvelopeSchema: z.ZodObject<{
 export interface VerifyEnvelopeInput {
     verificationId: string;
     target: {
-        kind: "spec" | "run" | "reduce";
+        kind: "spec" | "run" | "reduce" | "message";
         sessionId: string;
     };
     outputPath: string;
@@ -113,6 +124,14 @@ export interface ReduceEnvelopeInput {
     target: ReductionTarget;
     status: ReductionStatus;
 }
+export interface MessageEnvelopeInput {
+    sessionId: string;
+    status: "queued" | "running" | "succeeded" | "failed" | "aborted";
+    outputArtifacts?: ReadonlyArray<{
+        agentId: string;
+        outputPath?: string;
+    }>;
+}
 export interface ApplyEnvelopeInput {
     runId: string;
     agentId: string;
@@ -133,6 +152,7 @@ export declare function buildOperatorEnvelope(options: {
     unresolvedReasons?: OperatorResultEnvelope["unresolvedReasons"];
     alerts?: OperatorResultEnvelope["alerts"];
     error?: OperatorResultEnvelope["error"];
+    target?: OperatorResultEnvelope["target"];
     timestamp?: string;
 }): OperatorResultEnvelope;
 export declare function buildFailedOperatorEnvelope(options: {
@@ -150,6 +170,7 @@ export declare function buildRunOperatorEnvelope(options: {
 }): OperatorResultEnvelope;
 export declare function buildVerifyOperatorEnvelope(options: VerifyEnvelopeInput): OperatorResultEnvelope;
 export declare function buildReduceOperatorEnvelope(options: ReduceEnvelopeInput): OperatorResultEnvelope;
+export declare function buildMessageOperatorEnvelope(options: MessageEnvelopeInput): OperatorResultEnvelope;
 export declare function buildApplyOperatorEnvelope(options: ApplyEnvelopeInput): OperatorResultEnvelope;
 export declare function buildPruneOperatorEnvelope(options: PruneEnvelopeInput): OperatorResultEnvelope;
 export declare function writeOperatorResultEnvelope(envelope: OperatorResultEnvelope, exitCode?: number): void;

package/dist/cli/operator-envelope.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { getReductionSessionDirectoryPath, getRunDirectoryPath, getSpecSessionDirectoryPath, } from "../workspace/structure.js";
+import { getMessageSessionDirectoryPath, getReductionSessionDirectoryPath, getRunDirectoryPath, getSpecSessionDirectoryPath, } from "../workspace/structure.js";
 import { externalExecutionOperators } from "./contract.js";
 import { toCliError } from "./errors.js";
 export const operatorResultEnvelopeSchema = z
@@ -14,10 +14,18 @@ export const operatorResultEnvelopeSchema = z
         runId: z.string().optional(),
         verificationId: z.string().optional(),
         reductionId: z.string().optional(),
+        messageId: z.string().optional(),
         agentId: z.string().optional(),
     })
         .passthrough()
         .optional(),
+    target: z
+        .object({
+        kind: z.string(),
+        sessionId: z.string(),
+    })
+        .passthrough()
+        .optional(),
     artifacts: z.array(z
         .object({
         kind: z.string(),
@@ -73,6 +81,9 @@ export function buildOperatorEnvelope(options) {
     if (options.selection) {
         envelope.selection = options.selection;
     }
+    if (options.target) {
+        envelope.target = options.target;
+    }
     if (options.status === "unresolved" &&
         options.unresolvedReasons &&
         options.unresolvedReasons.length > 0) {
@@ -153,6 +164,9 @@ export function buildVerifyOperatorEnvelope(options) {
     if (options.target.kind === "reduce") {
         ids.reductionId = options.target.sessionId;
     }
+    if (options.target.kind === "message") {
+        ids.messageId = options.target.sessionId;
+    }
     const alerts = [];
     if (options.warningMessage) {
         alerts.push({ level: "warn", message: options.warningMessage });
@@ -167,6 +181,7 @@ export function buildVerifyOperatorEnvelope(options) {
         operator: "verify",
         status,
         ids,
+        target: options.target,
         artifacts: [
             {
                 kind: "session",
@@ -235,6 +250,34 @@ export function buildReduceOperatorEnvelope(options) {
         ],
     });
 }
+export function buildMessageOperatorEnvelope(options) {
+    return buildOperatorEnvelope({
+        operator: "message",
+        status: normalizeTerminalStatus(options.status),
+        ids: {
+            sessionId: options.sessionId,
+        },
+        artifacts: [
+            {
+                kind: "session",
+                role: "session",
+                path: getMessageSessionDirectoryPath(options.sessionId),
+            },
+            ...(options.outputArtifacts ?? []).flatMap((artifact) => [
+                ...(artifact.outputPath
+                    ? [
+                        {
+                            kind: "output",
+                            role: "output",
+                            agentId: artifact.agentId,
+                            path: artifact.outputPath,
+                        },
+                    ]
+                    : []),
+            ]),
+        ],
+    });
+}
 export function buildApplyOperatorEnvelope(options) {
     return buildOperatorEnvelope({
         operator: "apply",
@@ -363,10 +406,12 @@ function getReductionSourcePath(target) {
             return `.voratiq/spec/sessions/${target.id}`;
         case "run":
             return `.voratiq/run/sessions/${target.id}`;
-        case "verify":
-            return `.voratiq/verify/sessions/${target.id}`;
         case "reduce":
             return `.voratiq/reduce/sessions/${target.id}`;
+        case "verify":
+            return `.voratiq/verify/sessions/${target.id}`;
+        case "message":
+            return `.voratiq/message/sessions/${target.id}`;
     }
 }
 function getAgentIdFromSessionArtifactPath(path, sessionId) {

package/dist/cli/reduce.js

@@ -11,7 +11,7 @@ import { createReduceRenderer, formatReduceElapsed, formatReducerDuration, rende
 import { createStageStartLineEmitter } from "../render/utils/stage-output.js";
 import { normalizePathForDisplay, relativeToRoot, resolvePath, } from "../utils/path.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 { parseReduceExecutionCommandOptions } from "./contract.js";
 import { buildReduceOperatorEnvelope, createSilentCliWriter, writeOperatorResultEnvelope, } from "./operator-envelope.js";
 import { writeCommandOutput } from "./output.js";
@@ -46,6 +46,8 @@ export async function runReduceCommand(options) {
         specsFilePath: workspacePaths.specsFile,
         runsFilePath: workspacePaths.runsFile,
         reductionsFilePath: workspacePaths.reductionsFile ?? resolveReductionIndexPath(root),
+        messagesFilePath: workspacePaths.messagesFile ??
+            resolveWorkspacePath(root, VORATIQ_MESSAGE_FILE),
         verificationsFilePath: workspacePaths.verificationsFile ??
             resolveWorkspacePath(root, VORATIQ_VERIFICATION_FILE),
         target,
@@ -159,8 +161,9 @@ export function createReduceCommand() {
         .description("Reduce artifact sets into a summarized form")
         .addOption(new Option("--spec <spec-id>", "Spec to reduce"))
         .addOption(new Option("--run <run-id>", "Run to reduce"))
-        .addOption(new Option("--verify <verify-id>", "Verification to reduce"))
         .addOption(new Option("--reduce <reduce-id>", "Reduction to reduce"))
+        .addOption(new Option("--verify <verify-id>", "Verification to reduce"))
+        .addOption(new Option("--message <message-id>", "Message session to reduce"))
         .addOption(new Option("--agent <agent-id>", "Set reducers directly (repeatable; order preserved)")
         .default([], "")
         .argParser(collectAgentOption))

package/dist/cli/verify.js

@@ -19,7 +19,7 @@ import { colorize } from "../utils/colors.js";
 import { toErrorMessage } from "../utils/errors.js";
 import { normalizePathForDisplay, relativeToRoot, resolvePath, } from "../utils/path.js";
 import { parsePositiveInteger } from "../utils/validators.js";
-import { resolveWorkspacePath, VORATIQ_REDUCTION_FILE, VORATIQ_VERIFICATION_FILE, VORATIQ_VERIFICATION_SESSIONS_DIR, } from "../workspace/structure.js";
+import { resolveWorkspacePath, VORATIQ_MESSAGE_FILE, VORATIQ_REDUCTION_FILE, VORATIQ_VERIFICATION_FILE, VORATIQ_VERIFICATION_SESSIONS_DIR, } from "../workspace/structure.js";
 import { parseVerifyExecutionCommandOptions } from "./contract.js";
 import { buildVerifyOperatorEnvelope, createSilentCliWriter, writeOperatorResultEnvelope, } from "./operator-envelope.js";
 import { writeCommandOutput } from "./output.js";
@@ -56,6 +56,8 @@ export async function runVerifyCommand(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),
         target,
@@ -120,6 +122,7 @@ export async function runVerifyCommand(options) {
             completedAt: execution.record.completedAt,
         }) ?? "—",
         workspacePath: normalizePathForDisplay(relativeToRoot(root, resolveWorkspacePath(root, VORATIQ_VERIFICATION_SESSIONS_DIR, execution.verificationId))),
+        target: execution.record.target,
         status: execution.record.status,
         methods: methodBlocks,
         suppressHint,
@@ -154,10 +157,11 @@ function parseMaxParallelOption(value) {
 }
 export function createVerifyCommand() {
     return new Command("verify")
-        .description("Verify a recorded spec, run, or reduction")
+        .description("Verify a recorded spec, run, reduction, or message session")
         .addOption(new Option("--spec <spec-id>", "Spec to verify"))
         .addOption(new Option("--run <run-id>", "Run to verify"))
         .addOption(new Option("--reduce <reduce-id>", "Reduction to verify"))
+        .addOption(new Option("--message <message-id>", "Message session to verify"))
         .addOption(new Option("--agent <agent-id>", "Set verifiers directly (repeatable; order preserved)")
         .default([], "")
         .argParser(collectAgentOption))

package/dist/commands/list/command.d.ts

@@ -4,6 +4,7 @@ export interface ListCommandInput {
     specsFilePath: string;
     runsFilePath: string;
     reductionsFilePath: string;
+    messagesFilePath: string;
     verificationsFilePath: string;
     operator: ListOperator;
     sessionId?: string;

package/dist/commands/list/command.js

@@ -1,9 +1,11 @@
+import { readMessageRecords, } from "../../domain/message/persistence/adapter.js";
 import { readReductionRecords, } from "../../domain/reduce/persistence/adapter.js";
 import { readRunRecords, } from "../../domain/run/persistence/adapter.js";
 import { readSpecRecords, } from "../../domain/spec/persistence/adapter.js";
 import { TERMINAL_VERIFICATION_STATUSES } from "../../domain/verify/model/types.js";
 import { readVerificationRecords, } from "../../domain/verify/persistence/adapter.js";
-import { renderListTableTranscript, renderReduceList, renderRunList, renderSpecList, renderVerifyList, } from "../../render/transcripts/list.js";
+import { renderListTableTranscript, renderMessageList, renderReduceList, renderRunList, renderSpecList, renderVerifyList, } from "../../render/transcripts/list.js";
+import { formatMessageElapsed, formatMessageRecipientDuration, renderMessageTranscript, } from "../../render/transcripts/message.js";
 import { formatReduceElapsed, formatReducerDuration, renderReduceTranscript, } from "../../render/transcripts/reduce.js";
 import { formatRunElapsed, renderRunTranscript, } from "../../render/transcripts/run.js";
 import { formatSpecAgentDuration, formatSpecElapsed, renderSpecTranscript, } from "../../render/transcripts/spec.js";
@@ -12,7 +14,7 @@ import { formatAgentDuration } from "../../render/utils/agents.js";
 import { formatRenderLifecycleDuration } from "../../render/utils/duration.js";
 import { formatCompactDiffStatistics } from "../../utils/diff.js";
 import { pathExists } from "../../utils/fs.js";
-import { getReductionSessionDirectoryPath, getRunDirectoryPath, getSpecSessionDirectoryPath, getVerificationSessionDirectoryPath, } from "../../workspace/structure.js";
+import { getMessageSessionDirectoryPath, getReductionSessionDirectoryPath, getRunDirectoryPath, getSpecSessionDirectoryPath, getVerificationSessionDirectoryPath, } from "../../workspace/structure.js";
 const DEFAULT_LIMIT = 10;
 const DASH = "—";
 export async function executeListCommand(input) {
@@ -95,9 +97,11 @@ function renderTableOutput(operator, records) {
         ? renderRunList(records)
         : operator === "spec"
             ? renderSpecList(records)
-            : operator === "reduce"
-                ? renderReduceList(records)
-                : renderVerifyList(records);
+            : operator === "message"
+                ? renderMessageList(records)
+                : operator === "reduce"
+                    ? renderReduceList(records)
+                    : renderVerifyList(records);
     return renderListTableTranscript(table);
 }
 function renderDetailOutput(operator, record) {
@@ -175,6 +179,32 @@ function renderDetailOutput(operator, record) {
             isTty: process.stdout.isTTY,
         });
     }
+    if (operator === "message") {
+        const messageRecord = record;
+        return renderMessageTranscript({
+            messageId: messageRecord.sessionId,
+            createdAt: messageRecord.createdAt,
+            elapsed: formatMessageElapsed({
+                status: messageRecord.status,
+                startedAt: messageRecord.startedAt,
+                completedAt: messageRecord.completedAt,
+            }) ?? DASH,
+            workspacePath: getMessageSessionDirectoryPath(messageRecord.sessionId),
+            status: messageRecord.status,
+            recipients: messageRecord.recipients.map((recipient) => ({
+                agentId: recipient.agentId,
+                status: recipient.status,
+                duration: formatMessageRecipientDuration({
+                    status: recipient.status,
+                    startedAt: recipient.startedAt,
+                    completedAt: recipient.completedAt,
+                }) ?? DASH,
+                outputPath: recipient.outputPath,
+                errorLine: recipient.error ?? undefined,
+            })),
+            isTty: process.stdout.isTTY,
+        });
+    }
     const verificationRecord = record;
     return renderVerifyTranscript({
         verificationId: verificationRecord.sessionId,
@@ -185,6 +215,7 @@ function renderDetailOutput(operator, record) {
             completedAt: verificationRecord.completedAt,
         }) ?? DASH,
         workspacePath: getVerificationSessionDirectoryPath(verificationRecord.sessionId),
+        target: verificationRecord.target,
         status: verificationRecord.status,
         methods: verificationRecord.methods.map((method) => ({
             verifierLabel: method.method === "programmatic"
@@ -231,6 +262,15 @@ function toJsonTableRecord(operator, record) {
             },
         };
     }
+    if (operator === "message") {
+        const messageRecord = record;
+        return {
+            id: messageRecord.sessionId,
+            status: messageRecord.status,
+            createdAt: messageRecord.createdAt,
+            promptPreview: normalizePreviewText(messageRecord.prompt),
+        };
+    }
     const verificationRecord = record;
     return {
         id: verificationRecord.sessionId,
@@ -275,10 +315,26 @@ function toJsonDetailSession(operator, record) {
             createdAt: reductionRecord.createdAt,
             elapsed: formatReductionRecordElapsed(reductionRecord),
             workspacePath: getReductionSessionDirectoryPath(reductionRecord.sessionId),
+            target: {
+                kind: reductionRecord.target.type,
+                id: reductionRecord.target.id,
+            },
             rows: reductionRecord.reducers.map(toReductionJsonRow),
             artifacts: reductionRecord.reducers.map(toReductionArtifact),
         };
     }
+    if (operator === "message") {
+        const messageRecord = record;
+        return {
+            id: messageRecord.sessionId,
+            status: messageRecord.status,
+            createdAt: messageRecord.createdAt,
+            elapsed: formatMessageRecordElapsed(messageRecord),
+            workspacePath: getMessageSessionDirectoryPath(messageRecord.sessionId),
+            rows: messageRecord.recipients.map(toMessageJsonRow),
+            artifacts: messageRecord.recipients.flatMap(toMessageArtifacts),
+        };
+    }
     const verificationRecord = record;
     return {
         id: verificationRecord.sessionId,
@@ -286,6 +342,10 @@ function toJsonDetailSession(operator, record) {
         createdAt: verificationRecord.createdAt,
         elapsed: formatVerificationRecordElapsed(verificationRecord),
         workspacePath: getVerificationSessionDirectoryPath(verificationRecord.sessionId),
+        target: {
+            kind: verificationRecord.target.kind,
+            id: verificationRecord.target.sessionId,
+        },
         rows: verificationRecord.methods.map(toVerificationJsonRow),
         artifacts: verificationRecord.methods.map(toVerificationArtifact),
     };
@@ -311,6 +371,20 @@ function formatReductionRecordElapsed(record) {
         completedAt: record.completedAt,
     });
 }
+function formatMessageRecordElapsed(record) {
+    return formatMessageElapsed({
+        status: record.status,
+        startedAt: record.startedAt,
+        completedAt: record.completedAt,
+    });
+}
+function normalizePreviewText(value) {
+    if (!value) {
+        return null;
+    }
+    const normalized = value.replace(/\s+/gu, " ").trim();
+    return normalized.length > 0 ? normalized : null;
+}
 function formatVerificationRecordElapsed(record) {
     return formatVerifyElapsed({
         status: record.status,
@@ -373,6 +447,26 @@ function toReductionArtifact(reducer) {
         path: reducer.outputPath ?? null,
     };
 }
+function toMessageJsonRow(recipient) {
+    return {
+        agentId: recipient.agentId,
+        status: recipient.status,
+        duration: formatMessageRecipientDuration({
+            status: recipient.status,
+            startedAt: recipient.startedAt,
+            completedAt: recipient.completedAt,
+        }) ?? DASH,
+    };
+}
+function toMessageArtifacts(recipient) {
+    return [
+        {
+            kind: "output",
+            agentId: recipient.agentId,
+            path: recipient.outputPath ?? null,
+        },
+    ];
+}
 function getVerificationMethodLabel(method) {
     return method.method === "programmatic"
         ? "programmatic"
@@ -456,6 +550,23 @@ async function readOperatorRecords(input) {
             warnings: warnings.map(formatSessionWarning),
         };
     }
+    if (operator === "message") {
+        if (!(await pathExists(input.messagesFilePath))) {
+            return { records: [], warnings: [] };
+        }
+        const warnings = [];
+        const records = await readMessageRecords({
+            root,
+            messagesFilePath: input.messagesFilePath,
+            limit: input.limit,
+            predicate: input.predicate,
+            onWarning: (warning) => warnings.push(warning),
+        });
+        return {
+            records,
+            warnings: warnings.map(formatSessionWarning),
+        };
+    }
     if (!(await pathExists(input.verificationsFilePath))) {
         return { records: [], warnings: [] };
     }
@@ -482,8 +593,7 @@ function getRecordId(operator, record) {
     if (operator === "run") {
         return record.runId;
     }
-    return record
-        .sessionId;
+    return record.sessionId;
 }
 function formatSessionWarning(warning) {
     return `Ignoring corrupt session ${warning.displayPath}`;

package/dist/commands/message/command.d.ts

@@ -0,0 +1,23 @@
+import type { ResolvedExtraContextFile } from "../../competition/shared/extra-context.js";
+import { type MessageCompetitionExecution } from "../../domain/message/competition/adapter.js";
+import { type MessageRecipientEntry, type MessageRecord } from "../../domain/message/model/types.js";
+import type { MessageProgressRenderer } from "../../render/transcripts/message.js";
+export interface ExecuteMessageCommandInput {
+    root: string;
+    messagesFilePath: string;
+    prompt: string;
+    agentIds?: readonly string[];
+    agentOverrideFlag?: string;
+    profileName?: string;
+    maxParallel?: number;
+    extraContextFiles?: readonly ResolvedExtraContextFile[];
+    sourceInteractiveSessionId?: string;
+    renderer?: MessageProgressRenderer;
+}
+export interface ExecuteMessageCommandResult {
+    messageId: string;
+    record: MessageRecord;
+    recipients: readonly MessageRecipientEntry[];
+    executions: readonly MessageCompetitionExecution[];
+}
+export declare function executeMessageCommand(input: ExecuteMessageCommandInput): Promise<ExecuteMessageCommandResult>;