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

package/dist/domain/verify/competition/shared-layout.js

@@ -1,10 +1,10 @@
 import { copyFile, mkdir, rm, symlink, writeFile } from "node:fs/promises";
-import { dirname, join, relative as relativePath, resolve, sep, } from "node:path";
+import { basename, dirname, join, relative as relativePath, resolve, sep, } from "node:path";
 import { pathExists } from "../../../utils/fs.js";
 import { createDetachedWorktree, removeWorktree } from "../../../utils/git.js";
 import { ensureWorkspaceDependencies } from "../../../workspace/dependencies.js";
 import { buildAgentWorkspacePaths, } from "../../../workspace/layout.js";
-import { VORATIQ_VERIFICATION_SESSIONS_DIR } from "../../../workspace/structure.js";
+import { MESSAGE_RESPONSE_FILENAME, VORATIQ_VERIFICATION_SESSIONS_DIR, } from "../../../workspace/structure.js";
 import { aliasForCandidate } from "./blinding.js";
 const BLINDED_VERIFY_SPEC_ARTIFACT_ALLOWLIST = [
     {
@@ -36,20 +36,22 @@ export async function prepareSharedVerificationInputs(options) {
     const sharedInputsAbsolute = resolve(sharedRootAbsolute, "inputs");
     const referenceRepoAbsolute = resolve(sharedRootAbsolute, "reference", "repo");
     await mkdir(sharedInputsAbsolute, { recursive: true });
-    await mkdir(dirname(referenceRepoAbsolute), { recursive: true });
     let detachedWorktreeCreated = false;
     try {
-        await createDetachedWorktree({
-            root,
-            worktreePath: referenceRepoAbsolute,
-            baseRevision: resolvedTarget.baseRevisionSha,
-        });
-        detachedWorktreeCreated = true;
-        await ensureWorkspaceDependencies({
-            root,
-            workspacePath: referenceRepoAbsolute,
-            environment,
-        });
+        if ("baseRevisionSha" in resolvedTarget) {
+            await mkdir(dirname(referenceRepoAbsolute), { recursive: true });
+            await createDetachedWorktree({
+                root,
+                worktreePath: referenceRepoAbsolute,
+                baseRevision: resolvedTarget.baseRevisionSha,
+            });
+            detachedWorktreeCreated = true;
+            await ensureWorkspaceDependencies({
+                root,
+                workspacePath: referenceRepoAbsolute,
+                environment,
+            });
+        }
         if ("specRecord" in resolvedTarget) {
             const descriptionAbsolute = resolve(sharedInputsAbsolute, "description.md");
             await writeFile(descriptionAbsolute, `${resolvedTarget.specRecord.description.trimEnd()}\n`, "utf8");
@@ -126,6 +128,38 @@ export async function prepareSharedVerificationInputs(options) {
                 candidates,
             };
         }
+        if ("messageRecord" in resolvedTarget) {
+            const promptAbsolute = resolve(sharedInputsAbsolute, "prompt.md");
+            await writeFile(promptAbsolute, `${resolvedTarget.messageRecord.prompt.trimEnd()}\n`, "utf8");
+            const candidatesDir = resolve(sharedInputsAbsolute, "candidates");
+            await mkdir(candidatesDir, { recursive: true });
+            const candidates = await Promise.all(resolvedTarget.messageRecord.recipients
+                .filter((recipient) => recipient.status === "succeeded" &&
+                typeof recipient.outputPath === "string" &&
+                basename(recipient.outputPath) === MESSAGE_RESPONSE_FILENAME)
+                .map(async (recipient) => {
+                const alias = aliasForCandidate(recipient.agentId, aliasMap);
+                const dir = resolve(candidatesDir, alias);
+                await mkdir(dir, { recursive: true });
+                await copyRetainedVerificationArtifact({
+                    root,
+                    sourceRelativePath: recipient.outputPath,
+                    destinationAbsolute: resolve(dir, "response.md"),
+                    ownerLabel: `Message \`${resolvedTarget.target.sessionId}\` recipient \`${recipient.agentId}\``,
+                    artifactLabel: "response.md",
+                    required: true,
+                });
+                return { alias };
+            }));
+            return {
+                kind: "message",
+                sharedRootAbsolute,
+                sharedInputsAbsolute,
+                worktreesToRemove: [],
+                promptAbsolute,
+                candidates,
+            };
+        }
         const candidatesDir = resolve(sharedInputsAbsolute, "candidates");
         await mkdir(candidatesDir, { recursive: true });
         const candidates = await Promise.all(resolvedTarget.reductionRecord.reducers
@@ -144,6 +178,16 @@ export async function prepareSharedVerificationInputs(options) {
             });
             return { alias };
         }));
+        if ("referenceRepoUnavailable" in resolvedTarget) {
+            return {
+                kind: "reduce-no-reference",
+                sharedRootAbsolute,
+                sharedInputsAbsolute,
+                worktreesToRemove: [],
+                referenceRepoUnavailable: resolvedTarget.referenceRepoUnavailable,
+                candidates,
+            };
+        }
         return {
             kind: "reduce",
             sharedRootAbsolute,
@@ -216,6 +260,26 @@ export function buildStagedVerificationInputs(options) {
             })),
         };
     }
+    if (sharedInputs.kind === "message") {
+        return {
+            kind: "message",
+            promptPath: toWorkspaceRelative(workspacePaths.workspacePath, resolve(inputsRoot, "prompt.md")),
+            candidates: sharedInputs.candidates.map((candidate) => ({
+                alias: candidate.alias,
+                responsePath: toWorkspaceRelative(workspacePaths.workspacePath, resolve(inputsRoot, "candidates", candidate.alias, "response.md")),
+            })),
+        };
+    }
+    if (sharedInputs.kind === "reduce-no-reference") {
+        return {
+            kind: "reduce-no-reference",
+            referenceRepoUnavailable: sharedInputs.referenceRepoUnavailable,
+            candidates: sharedInputs.candidates.map((candidate) => ({
+                alias: candidate.alias,
+                reductionPath: toWorkspaceRelative(workspacePaths.workspacePath, resolve(inputsRoot, "candidates", candidate.alias, "reduction.md")),
+            })),
+        };
+    }
     return {
         kind: "reduce",
         referenceRepoPath: "reference_repo",
@@ -225,17 +289,24 @@ export function buildStagedVerificationInputs(options) {
         })),
     };
 }
+export function sharedInputsUseReferenceRepo(sharedInputs) {
+    return (sharedInputs.kind === "spec" ||
+        sharedInputs.kind === "run" ||
+        sharedInputs.kind === "reduce");
+}
 export async function attachVerifierWorkspaceMounts(options) {
-    const { workspacePath, contextPath, sharedInputsAbsolute, referenceRepoAbsolute, } = options;
+    const { workspacePath, contextPath, sharedInputs } = options;
     await attachSharedInputsToVerifierWorkspace({
         workspacePath,
-        sharedInputsAbsolute,
-    });
-    await attachWorkspaceDirectorySymlink({
-        workspacePath,
-        mountName: "reference_repo",
-        targetAbsolutePath: referenceRepoAbsolute,
+        sharedInputsAbsolute: sharedInputs.sharedInputsAbsolute,
     });
+    if (sharedInputsUseReferenceRepo(sharedInputs)) {
+        await attachWorkspaceDirectorySymlink({
+            workspacePath,
+            mountName: "reference_repo",
+            targetAbsolutePath: sharedInputs.referenceRepoAbsolute,
+        });
+    }
     await attachWorkspaceDirectorySymlink({
         workspacePath,
         mountName: "context",

package/dist/domain/verify/competition/target.d.ts

@@ -1,3 +1,4 @@
+import type { MessageRecord } from "../../message/model/types.js";
 import type { ReductionRecord } from "../../reduce/model/types.js";
 import type { RunRecord } from "../../run/model/types.js";
 import type { SpecRecord } from "../../spec/model/types.js";
@@ -27,4 +28,20 @@ export type ResolvedVerificationTarget = {
         kind: "reduce";
     }>;
     reductionRecord: ReductionRecord;
+} | {
+    competitiveCandidates: readonly VerificationCompetitiveCandidate[];
+    target: Extract<VerificationTarget, {
+        kind: "reduce";
+    }>;
+    reductionRecord: ReductionRecord;
+    referenceRepoUnavailable: {
+        reason: "message-lineage";
+        messageSessionId: string;
+    };
+} | {
+    competitiveCandidates: readonly VerificationCompetitiveCandidate[];
+    target: Extract<VerificationTarget, {
+        kind: "message";
+    }>;
+    messageRecord: MessageRecord;
 };

package/dist/domain/verify/model/types.d.ts

@@ -3,13 +3,14 @@ import { type VerificationStatus } from "../../../status/index.js";
 export { TERMINAL_VERIFICATION_STATUSES, verificationStatusSchema, } from "../../../status/index.js";
 export type { RubricRecommendation, RubricResultPayload, } from "../rubric-result.js";
 export type { VerificationStatus };
-declare const VERIFICATION_TARGET_KIND_VALUES: readonly ["spec", "run", "reduce"];
+declare const VERIFICATION_TARGET_KIND_VALUES: readonly ["spec", "run", "reduce", "message"];
 declare const VERIFICATION_METHOD_KIND_VALUES: readonly ["programmatic", "rubric"];
 declare const VERIFICATION_SCOPE_KIND_VALUES: readonly ["target", "run", "candidate"];
 export type VerificationTargetKind = (typeof VERIFICATION_TARGET_KIND_VALUES)[number];
 export type VerificationMethodKind = (typeof VERIFICATION_METHOD_KIND_VALUES)[number];
 export type VerificationScopeKind = (typeof VERIFICATION_SCOPE_KIND_VALUES)[number];
 export declare const verificationTargetKindSchema: z.ZodEnum<{
+    message: "message";
     reduce: "reduce";
     spec: "spec";
     run: "run";
@@ -19,8 +20,8 @@ export declare const verificationMethodKindSchema: z.ZodEnum<{
     rubric: "rubric";
 }>;
 export declare const verificationScopeKindSchema: z.ZodEnum<{
-    run: "run";
     target: "target";
+    run: "run";
     candidate: "candidate";
 }>;
 export declare const specVerificationTargetSchema: z.ZodObject<{
@@ -37,6 +38,10 @@ export declare const reduceVerificationTargetSchema: z.ZodObject<{
     kind: z.ZodLiteral<"reduce">;
     sessionId: z.ZodString;
 }, z.core.$strict>;
+export declare const messageVerificationTargetSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"message">;
+    sessionId: z.ZodString;
+}, z.core.$strict>;
 export declare const verificationTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"spec">;
     sessionId: z.ZodString;
@@ -48,6 +53,9 @@ export declare const verificationTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObj
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"reduce">;
     sessionId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"message">;
+    sessionId: z.ZodString;
 }, z.core.$strict>], "kind">;
 export type VerificationTarget = z.infer<typeof verificationTargetSchema>;
 export declare const verificationScopeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -139,6 +147,9 @@ export declare const programmaticResultArtifactSchema: z.ZodDiscriminatedUnion<[
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"reduce">;
         sessionId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"message">;
+        sessionId: z.ZodString;
     }, z.core.$strict>]>;
     scope: z.ZodLiteral<"target">;
     results: z.ZodArray<z.ZodObject<{
@@ -223,6 +234,9 @@ export declare const verificationResultArtifactSchema: z.ZodUnion<readonly [z.Zo
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"reduce">;
         sessionId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"message">;
+        sessionId: z.ZodString;
     }, z.core.$strict>]>;
     scope: z.ZodLiteral<"target">;
     results: z.ZodArray<z.ZodObject<{
@@ -310,6 +324,9 @@ export declare const verificationRecordSchema: z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"reduce">;
         sessionId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"message">;
+        sessionId: z.ZodString;
     }, z.core.$strict>], "kind">;
     extraContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
     extraContextMetadata: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -381,6 +398,7 @@ export declare const verificationIndexEntrySchema: z.ZodObject<{
         aborted: "aborted";
     }>;
     targetKind: z.ZodEnum<{
+        message: "message";
         reduce: "reduce";
         spec: "spec";
         run: "run";

package/dist/domain/verify/model/types.js

@@ -9,7 +9,12 @@ import { validateRecordLifecycleTimestamps } from "../../shared/lifecycle.js";
 import { BLINDED_ALIAS_PATTERN } from "../blinding/aliases.js";
 import { rubricResultPayloadSchema, safeParseRubricRecommendationFromResult, } from "../rubric-result.js";
 export { TERMINAL_VERIFICATION_STATUSES, verificationStatusSchema, } from "../../../status/index.js";
-const VERIFICATION_TARGET_KIND_VALUES = ["spec", "run", "reduce"];
+const VERIFICATION_TARGET_KIND_VALUES = [
+    "spec",
+    "run",
+    "reduce",
+    "message",
+];
 const VERIFICATION_METHOD_KIND_VALUES = ["programmatic", "rubric"];
 const VERIFICATION_SCOPE_KIND_VALUES = ["target", "run", "candidate"];
 const RUBRIC_FINDING_SEVERITY_VALUES = ["info", "warning", "error"];
@@ -39,10 +44,17 @@ export const reduceVerificationTargetSchema = z
     sessionId: z.string().min(1),
 })
     .strict();
+export const messageVerificationTargetSchema = z
+    .object({
+    kind: z.literal("message"),
+    sessionId: z.string().min(1),
+})
+    .strict();
 export const verificationTargetSchema = z.discriminatedUnion("kind", [
     specVerificationTargetSchema,
     runVerificationTargetSchema,
     reduceVerificationTargetSchema,
+    messageVerificationTargetSchema,
 ]);
 export const verificationScopeSchema = z.discriminatedUnion("kind", [
     z.object({ kind: z.literal("target") }).strict(),
@@ -151,6 +163,7 @@ export const programmaticResultArtifactSchema = z.discriminatedUnion("scope", [
         target: z.union([
             specVerificationTargetSchema,
             reduceVerificationTargetSchema,
+            messageVerificationTargetSchema,
         ]),
         scope: z.literal("target"),
         results: z.array(programmaticCheckResultSchema),
@@ -260,7 +273,7 @@ export const verificationRecordSchema = z
             ctx.addIssue({
                 code: z.ZodIssueCode.custom,
                 path: ["methods"],
-                message: "spec and reduce verification refs must use `target` scope only",
+                message: "spec, reduce, and message verification refs must use `target` scope only",
             });
         }
     }

package/dist/mcp/server.d.ts

@@ -1,9 +1,9 @@
 import { createEntrypointVoratiqCliTarget as createEntrypointCliTarget, resolveVoratiqCliTarget, type VoratiqCliTarget } from "../utils/voratiq-cli-target.js";
 export declare const VORATIQ_MCP_PROTOCOL_VERSION: "2025-11-25";
 export declare const VORATIQ_SUPPORTED_MCP_PROTOCOL_VERSIONS: readonly ["2025-11-25", "2025-06-18", "2024-11-05"];
-export type VoratiqMcpExecutionToolName = "voratiq_spec" | "voratiq_run" | "voratiq_reduce" | "voratiq_verify" | "voratiq_apply" | "voratiq_prune";
+export type VoratiqMcpExecutionToolName = "voratiq_spec" | "voratiq_run" | "voratiq_reduce" | "voratiq_verify" | "voratiq_message" | "voratiq_apply" | "voratiq_prune";
 export type VoratiqMcpToolName = VoratiqMcpExecutionToolName | "voratiq_list";
-export type VoratiqMcpOperator = "spec" | "run" | "reduce" | "verify" | "apply" | "prune" | "list";
+export type VoratiqMcpOperator = "spec" | "run" | "reduce" | "verify" | "message" | "apply" | "list" | "prune";
 export type TransportFailureKind = "invalid_input" | "spawn_failed" | "malformed_json" | "contract_mismatch";
 export interface TransportFailureResult {
     failureKind: TransportFailureKind;

package/dist/mcp/server.js

@@ -1,7 +1,7 @@
 import { spawn } from "node:child_process";
 import process from "node:process";
 import { z } from "zod";
-import { externalApplyExecutionInputSchema, externalListInspectionInputSchema, externalPruneExecutionInputSchema, externalReduceExecutionInputSchema, externalRunExecutionInputSchema, externalSpecExecutionInputSchema, externalVerifyExecutionInputSchema, } from "../cli/contract.js";
+import { externalApplyExecutionInputSchema, externalListInspectionInputSchema, externalMessageExecutionInputSchema, externalPruneExecutionInputSchema, externalReduceExecutionInputSchema, externalRunExecutionInputSchema, externalSpecExecutionInputSchema, externalVerifyExecutionInputSchema, } from "../cli/contract.js";
 import { operatorResultEnvelopeSchema, } from "../cli/operator-envelope.js";
 import { listJsonOutputSchema, } from "../contracts/list.js";
 import { getVoratiqVersion } from "../utils/version.js";
@@ -62,11 +62,19 @@ const toolSpecs = [
     {
         name: "voratiq_verify",
         operator: "verify",
-        description: "Verify a Voratiq spec, run, or reduction session and record the evaluation result.",
+        description: "Verify a Voratiq spec, run, reduction, or message session and record the evaluation result.",
         inputSchemaSource: externalVerifyExecutionInputSchema,
         buildArgs: (input) => buildVerifyExecutionArgs(input),
         outputContract: "execution",
     },
+    {
+        name: "voratiq_message",
+        operator: "message",
+        description: "Send an isolated prompt to one or more Voratiq agents and persist their independent replies as a durable message session.",
+        inputSchemaSource: externalMessageExecutionInputSchema,
+        buildArgs: (input) => buildMessageExecutionArgs(input),
+        outputContract: "execution",
+    },
     {
         name: "voratiq_apply",
         operator: "apply",
@@ -75,6 +83,15 @@ const toolSpecs = [
         buildArgs: (input) => buildApplyExecutionArgs(input),
         outputContract: "execution",
     },
+    {
+        name: "voratiq_list",
+        operator: "list",
+        description: "List recorded Voratiq sessions for one operator (`spec`, `run`, `reduce`, `verify`, or `message`) in table or detail mode.",
+        inputSchemaSource: externalListInspectionInputSchema,
+        mcpInputSchema: createListMcpInputSchema(),
+        buildArgs: (input) => buildListInspectionArgs(input),
+        outputContract: "list",
+    },
     {
         name: "voratiq_prune",
         operator: "prune",
@@ -84,22 +101,13 @@ const toolSpecs = [
         buildArgs: (input) => buildPruneExecutionArgs(input),
         outputContract: "execution",
     },
-    {
-        name: "voratiq_list",
-        operator: "list",
-        description: "List recorded Voratiq sessions for one operator (`spec`, `run`, `reduce`, or `verify`) in table or detail mode.",
-        inputSchemaSource: externalListInspectionInputSchema,
-        mcpInputSchema: createListMcpInputSchema(),
-        buildArgs: (input) => buildListInspectionArgs(input),
-        outputContract: "list",
-    },
 ];
 const toolDefinitions = toolSpecs.map((tool) => ({
     name: tool.name,
     description: tool.description,
     inputSchema: tool.mcpInputSchema ?? toToolInputJsonSchema(tool.inputSchemaSource),
 }));
-const VORATIQ_MCP_SERVER_INSTRUCTIONS = "Voratiq tools operate on Voratiq workflow state in the current repository. Use voratiq_list for questions about recent or specific spec, run, reduce, or verify sessions. Use voratiq_spec, voratiq_run, voratiq_verify, voratiq_apply, and voratiq_prune for the normal Voratiq workflow. Prefer these tools over shell inspection when the task is about Voratiq workflow history or state.";
+const VORATIQ_MCP_SERVER_INSTRUCTIONS = "Voratiq tools operate on Voratiq workflow state in the current repository. Use voratiq_list for questions about recent or specific spec, run, reduce, verify, or message sessions. Use voratiq_spec, voratiq_run, voratiq_reduce, voratiq_verify, voratiq_message, voratiq_apply, and voratiq_prune for the normal Voratiq workflow. Prefer these tools over shell inspection when the task is about Voratiq workflow history or state.";
 const toolSpecsByName = new Map(toolSpecs.map((tool) => [tool.name, tool]));
 export function getVoratiqMcpToolDefinitions() {
     return toolDefinitions;
@@ -416,6 +424,15 @@ function buildRunExecutionArgs(input) {
     args.push("--json");
     return args;
 }
+function buildMessageExecutionArgs(input) {
+    const args = ["message", "--prompt", input.prompt];
+    appendRepeatedStringFlag(args, "--agent", input.agentIds);
+    appendOptionalStringFlag(args, "--profile", input.profile);
+    appendOptionalNumberFlag(args, "--max-parallel", input.maxParallel);
+    appendRepeatedStringFlag(args, "--extra-context", input.extraContext);
+    args.push("--json");
+    return args;
+}
 function buildReduceExecutionArgs(input) {
     const args = ["reduce", `--${input.target.type}`, input.target.id];
     appendRepeatedStringFlag(args, "--agent", input.agentIds);
@@ -556,7 +573,7 @@ function createPruneMcpInputSchema() {
 function createListMcpInputSchema() {
     return toToolInputJsonSchema(z
         .object({
-        operator: z.enum(["spec", "run", "reduce", "verify"]),
+        operator: z.enum(["spec", "run", "reduce", "verify", "message"]),
         mode: z
             .enum(["table", "detail"])
             .describe("Use `detail` only when inspecting a specific session."),

package/dist/policy/verification.js

@@ -253,6 +253,8 @@ function resolveStageVerificationTemplateForTarget(target) {
             return "run-verification";
         case "reduce":
             return "reduce-verification";
+        case "message":
+            return "message-verification";
     }
 }
 function resolveCanonicalCandidateIds(options) {

package/dist/preflight/index.d.ts

@@ -9,6 +9,8 @@ export interface WorkspacePaths {
     runsFile: string;
     reductionsDir?: string;
     reductionsFile?: string;
+    messagesDir?: string;
+    messagesFile?: string;
     specsDir: string;
     specsFile: string;
     verificationsDir?: string;

package/dist/preflight/index.js

@@ -5,7 +5,7 @@ import { assertGitRepository, runGitCommand, } from "../utils/git.js";
 import { relativeToRoot } from "../utils/path.js";
 import { collectMissingSandboxDependencies, formatSandboxDependencyList, } from "../workspace/sandbox-requirements.js";
 import { repairWorkspaceStructure, validateWorkspace, } from "../workspace/setup.js";
-import { resolveWorkspacePath, VORATIQ_REDUCTION_DIR, VORATIQ_REDUCTION_FILE, VORATIQ_RUN_DIR, VORATIQ_RUN_FILE, VORATIQ_SPEC_DIR, VORATIQ_SPEC_FILE, VORATIQ_VERIFICATION_DIR, VORATIQ_VERIFICATION_FILE, } from "../workspace/structure.js";
+import { resolveWorkspacePath, VORATIQ_MESSAGE_DIR, VORATIQ_MESSAGE_FILE, VORATIQ_REDUCTION_DIR, VORATIQ_REDUCTION_FILE, VORATIQ_RUN_DIR, VORATIQ_RUN_FILE, VORATIQ_SPEC_DIR, VORATIQ_SPEC_FILE, VORATIQ_VERIFICATION_DIR, VORATIQ_VERIFICATION_FILE, } from "../workspace/structure.js";
 import { DirtyWorkingTreeError, SandboxDependenciesError, SpecNotFoundError, } from "./errors.js";
 export async function resolveCliContext(options = {}) {
     const { requireWorkspace = true, workspaceAutoInitMode = "never", restoreShippedVerificationTemplates = true, } = options;
@@ -43,6 +43,8 @@ export async function resolveCliContext(options = {}) {
         runsFile: resolveWorkspacePath(root, VORATIQ_RUN_FILE),
         reductionsDir: resolveWorkspacePath(root, VORATIQ_REDUCTION_DIR),
         reductionsFile: resolveWorkspacePath(root, VORATIQ_REDUCTION_FILE),
+        messagesDir: resolveWorkspacePath(root, VORATIQ_MESSAGE_DIR),
+        messagesFile: resolveWorkspacePath(root, VORATIQ_MESSAGE_FILE),
         specsDir: resolveWorkspacePath(root, VORATIQ_SPEC_DIR),
         specsFile: resolveWorkspacePath(root, VORATIQ_SPEC_FILE),
         verificationsDir: resolveWorkspacePath(root, VORATIQ_VERIFICATION_DIR),

package/dist/render/transcripts/list.d.ts

@@ -1,3 +1,4 @@
+import type { MessageRecord } from "../../domain/message/model/types.js";
 import type { ReductionRecord } from "../../domain/reduce/model/types.js";
 import type { RunRecord } from "../../domain/run/model/types.js";
 import type { SpecRecord } from "../../domain/spec/model/types.js";
@@ -6,5 +7,6 @@ export declare function renderRunList(records: readonly RunRecord[]): string;
 export declare function renderListTranscript(records: readonly RunRecord[]): string;
 export declare function renderSpecList(records: readonly SpecRecord[]): string;
 export declare function renderReduceList(records: readonly ReductionRecord[]): string;
+export declare function renderMessageList(records: readonly MessageRecord[]): string;
 export declare function renderVerifyList(records: readonly VerificationRecord[]): string;
 export declare function renderListTableTranscript(tableOutput: string): string;

package/dist/render/transcripts/list.js

@@ -3,6 +3,7 @@ import { renderTable } from "../utils/table.js";
 import { renderTranscript } from "../utils/transcript.js";
 const DASH = "—";
 const SPEC_DESCRIPTION_PREVIEW_LENGTH = 32;
+const MESSAGE_PROMPT_PREVIEW_LENGTH = 32;
 export function renderRunList(records) {
     const rows = records.map((record) => ({
         run: record.runId,
@@ -77,6 +78,29 @@ export function renderReduceList(records) {
         rows: records,
     }).join("\n");
 }
+export function renderMessageList(records) {
+    return renderTable({
+        columns: [
+            {
+                header: "MESSAGE",
+                accessor: (record) => record.sessionId,
+            },
+            {
+                header: "PROMPT",
+                accessor: (record) => truncatePreview(record.prompt, MESSAGE_PROMPT_PREVIEW_LENGTH),
+            },
+            {
+                header: "STATUS",
+                accessor: (record) => record.status.toUpperCase(),
+            },
+            {
+                header: "CREATED",
+                accessor: (record) => formatRunTimestamp(record.createdAt),
+            },
+        ],
+        rows: records,
+    }).join("\n");
+}
 export function renderVerifyList(records) {
     return renderTable({
         columns: [

package/dist/render/transcripts/message.d.ts

@@ -0,0 +1,72 @@
+import type { ExtractedTokenUsage } from "../../domain/run/model/types.js";
+import type { TokenUsageResult } from "../../workspace/chat/token-usage-result.js";
+type CliWriter = Pick<NodeJS.WriteStream, "write"> & {
+    isTTY?: boolean;
+    columns?: number;
+};
+export interface MessageProgressContext {
+    messageId: string;
+    createdAt: string;
+    startedAt?: string;
+    completedAt?: string;
+    workspacePath: string;
+    status: "queued" | "running" | "succeeded" | "failed" | "aborted";
+}
+export interface MessageProgressRecipientRecord {
+    agentId: string;
+    status: "queued" | "running" | "succeeded" | "failed" | "aborted";
+    startedAt?: string;
+    completedAt?: string;
+    outputPath?: string;
+    tokenUsage?: ExtractedTokenUsage;
+    tokenUsageResult?: TokenUsageResult;
+    error?: string | null;
+}
+export interface MessageProgressRenderer {
+    begin(context?: MessageProgressContext): void;
+    update(record: MessageProgressRecipientRecord): void;
+    complete(status?: MessageProgressContext["status"], lifecycle?: {
+        startedAt?: string;
+        completedAt?: string;
+    }): void;
+}
+export interface MessageTranscriptRecipientBlock {
+    agentId: string;
+    status: "queued" | "running" | "succeeded" | "failed" | "aborted";
+    duration: string;
+    outputPath?: string;
+    previewLines?: readonly string[];
+    errorLine?: string;
+}
+export interface MessageTranscriptOptions {
+    messageId: string;
+    createdAt: string;
+    elapsed: string;
+    workspacePath: string;
+    status: "queued" | "running" | "succeeded" | "failed" | "aborted";
+    recipients: readonly MessageTranscriptRecipientBlock[];
+    isTty?: boolean;
+    includeSummarySection?: boolean;
+}
+interface MessageRendererOptions {
+    stdout?: CliWriter;
+    stderr?: CliWriter;
+    now?: () => number;
+    suppressLeadingBlankLine?: boolean;
+    suppressTrailingBlankLine?: boolean;
+}
+export declare function createMessageRenderer(options?: MessageRendererOptions): MessageProgressRenderer;
+export declare function renderMessageTranscript(options: MessageTranscriptOptions): string;
+export declare function formatMessageElapsed(input: {
+    status: MessageProgressContext["status"];
+    startedAt?: string;
+    completedAt?: string;
+    now?: number;
+}): string | undefined;
+export declare function formatMessageRecipientDuration(input: {
+    status: MessageProgressRecipientRecord["status"];
+    startedAt?: string;
+    completedAt?: string;
+    now?: number;
+}): string | undefined;
+export {};