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

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

@@ -0,0 +1,100 @@
+import { z } from "zod";
+import { type MessageRecipientStatus, messageRecipientStatusSchema, type MessageStatus, messageStatusSchema, TERMINAL_MESSAGE_RECIPIENT_STATUSES, TERMINAL_MESSAGE_STATUSES } from "../../../status/index.js";
+export type { MessageRecipientStatus, MessageStatus };
+export { messageRecipientStatusSchema, messageStatusSchema, TERMINAL_MESSAGE_RECIPIENT_STATUSES, TERMINAL_MESSAGE_STATUSES, };
+export declare const messageRecipientEntrySchema: z.ZodObject<{
+    agentId: z.ZodString;
+    status: z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+        aborted: "aborted";
+    }>;
+    startedAt: z.ZodOptional<z.ZodString>;
+    completedAt: z.ZodOptional<z.ZodString>;
+    outputPath: z.ZodOptional<z.ZodString>;
+    stdoutPath: z.ZodOptional<z.ZodString>;
+    stderrPath: z.ZodOptional<z.ZodString>;
+    tokenUsage: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        input_tokens: z.ZodOptional<z.ZodNumber>;
+        output_tokens: z.ZodOptional<z.ZodNumber>;
+        cache_read_input_tokens: z.ZodOptional<z.ZodNumber>;
+        cache_creation_input_tokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        input_tokens: z.ZodOptional<z.ZodNumber>;
+        cached_input_tokens: z.ZodOptional<z.ZodNumber>;
+        output_tokens: z.ZodOptional<z.ZodNumber>;
+        reasoning_output_tokens: z.ZodOptional<z.ZodNumber>;
+        total_tokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        input: z.ZodOptional<z.ZodNumber>;
+        output: z.ZodOptional<z.ZodNumber>;
+        cached: z.ZodOptional<z.ZodNumber>;
+        thoughts: z.ZodOptional<z.ZodNumber>;
+        tool: z.ZodOptional<z.ZodNumber>;
+        total: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>]>>;
+    error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type MessageRecipientEntry = z.infer<typeof messageRecipientEntrySchema>;
+export declare const messageRecordSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    createdAt: z.ZodString;
+    startedAt: z.ZodString;
+    completedAt: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+        aborted: "aborted";
+    }>;
+    baseRevisionSha: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodString;
+    sourceInteractiveSessionId: z.ZodOptional<z.ZodString>;
+    extraContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    extraContextMetadata: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        stagedPath: z.ZodString;
+        sourcePath: z.ZodString;
+    }, z.core.$strip>>>;
+    recipients: z.ZodArray<z.ZodObject<{
+        agentId: z.ZodString;
+        status: z.ZodEnum<{
+            queued: "queued";
+            running: "running";
+            succeeded: "succeeded";
+            failed: "failed";
+            aborted: "aborted";
+        }>;
+        startedAt: z.ZodOptional<z.ZodString>;
+        completedAt: z.ZodOptional<z.ZodString>;
+        outputPath: z.ZodOptional<z.ZodString>;
+        stdoutPath: z.ZodOptional<z.ZodString>;
+        stderrPath: z.ZodOptional<z.ZodString>;
+        tokenUsage: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            input_tokens: z.ZodOptional<z.ZodNumber>;
+            output_tokens: z.ZodOptional<z.ZodNumber>;
+            cache_read_input_tokens: z.ZodOptional<z.ZodNumber>;
+            cache_creation_input_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            input_tokens: z.ZodOptional<z.ZodNumber>;
+            cached_input_tokens: z.ZodOptional<z.ZodNumber>;
+            output_tokens: z.ZodOptional<z.ZodNumber>;
+            reasoning_output_tokens: z.ZodOptional<z.ZodNumber>;
+            total_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            input: z.ZodOptional<z.ZodNumber>;
+            output: z.ZodOptional<z.ZodNumber>;
+            cached: z.ZodOptional<z.ZodNumber>;
+            thoughts: z.ZodOptional<z.ZodNumber>;
+            tool: z.ZodOptional<z.ZodNumber>;
+            total: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>]>>;
+        error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type MessageRecord = z.infer<typeof messageRecordSchema>;
+export type MessageIndexEntry = Pick<MessageRecord, "sessionId" | "createdAt" | "status">;
+export declare function deriveMessageStatusFromRecipients(recipientStatuses: readonly MessageRecipientStatus[]): MessageStatus;

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

@@ -0,0 +1,87 @@
+import { z } from "zod";
+import { agentIdSchema } from "../../../configs/agents/types.js";
+import { extractedTokenUsageSchema } from "../../../domain/run/model/types.js";
+import { extraContextMetadataEntrySchema, persistedExtraContextPathSchema, } from "../../../persistence/extra-context.js";
+import { repoRelativeRecordPathSchema } from "../../../persistence/record-path-schema.js";
+import { messageRecipientStatusSchema, messageStatusSchema, TERMINAL_MESSAGE_RECIPIENT_STATUSES, TERMINAL_MESSAGE_STATUSES, } from "../../../status/index.js";
+import { validateOperationLifecycleTimestamps, validateRecordLifecycleTimestamps, } from "../../shared/lifecycle.js";
+export { messageRecipientStatusSchema, messageStatusSchema, TERMINAL_MESSAGE_RECIPIENT_STATUSES, TERMINAL_MESSAGE_STATUSES, };
+const RUNNING_MESSAGE_RECORD_STATUSES = [
+    "running",
+];
+export const messageRecipientEntrySchema = z
+    .object({
+    agentId: agentIdSchema,
+    status: messageRecipientStatusSchema,
+    startedAt: z.string().optional(),
+    completedAt: z.string().optional(),
+    outputPath: repoRelativeRecordPathSchema.optional(),
+    stdoutPath: repoRelativeRecordPathSchema.optional(),
+    stderrPath: repoRelativeRecordPathSchema.optional(),
+    tokenUsage: extractedTokenUsageSchema.optional(),
+    error: z.string().nullable().optional(),
+})
+    .superRefine((recipient, ctx) => {
+    if (recipient.status === "succeeded" && !recipient.outputPath) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["outputPath"],
+            message: "succeeded message recipients must persist `outputPath`",
+        });
+    }
+    validateOperationLifecycleTimestamps({
+        status: recipient.status,
+        startedAt: recipient.startedAt,
+        completedAt: recipient.completedAt,
+    }, ctx, {
+        queued: ["queued"],
+        running: ["running"],
+        terminal: TERMINAL_MESSAGE_RECIPIENT_STATUSES,
+    });
+});
+export const messageRecordSchema = z
+    .object({
+    sessionId: z.string(),
+    createdAt: z.string(),
+    startedAt: z.string(),
+    completedAt: z.string().optional(),
+    status: messageStatusSchema,
+    baseRevisionSha: z.string().optional(),
+    prompt: z.string(),
+    sourceInteractiveSessionId: z.string().optional(),
+    extraContext: z.array(persistedExtraContextPathSchema).optional(),
+    extraContextMetadata: z.array(extraContextMetadataEntrySchema).optional(),
+    recipients: z
+        .array(messageRecipientEntrySchema)
+        .min(1)
+        .superRefine((recipients, ctx) => {
+        const seen = new Set();
+        for (const recipient of recipients) {
+            if (seen.has(recipient.agentId)) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `Duplicate message recipient agent id: ${recipient.agentId}`,
+                });
+                return;
+            }
+            seen.add(recipient.agentId);
+        }
+    }),
+    error: z.string().nullable().optional(),
+})
+    .superRefine((record, ctx) => {
+    validateRecordLifecycleTimestamps({
+        status: record.status,
+        createdAt: record.createdAt,
+        startedAt: record.startedAt,
+        completedAt: record.completedAt,
+    }, ctx, {
+        queued: [],
+        running: RUNNING_MESSAGE_RECORD_STATUSES,
+        terminal: TERMINAL_MESSAGE_STATUSES,
+    });
+});
+export function deriveMessageStatusFromRecipients(recipientStatuses) {
+    const hasSuccess = recipientStatuses.some((status) => status === "succeeded");
+    return hasSuccess ? "succeeded" : "failed";
+}

package/dist/domain/message/persistence/adapter.d.ts

@@ -0,0 +1,43 @@
+import type { MessageRecord } from "../model/types.js";
+export type MessageRecordPredicate = (record: MessageRecord) => boolean;
+export interface MessageRecordWarningMissing {
+    kind: "missing-record";
+    sessionId: string;
+    recordPath: string;
+    displayPath: string;
+}
+export interface MessageRecordWarningParse {
+    kind: "parse-error";
+    sessionId: string;
+    recordPath: string;
+    displayPath: string;
+    details: string;
+}
+export type MessageRecordWarning = MessageRecordWarningMissing | MessageRecordWarningParse;
+export interface ReadMessageRecordsOptions {
+    root: string;
+    messagesFilePath: string;
+    limit?: number;
+    predicate?: MessageRecordPredicate;
+    onWarning?: (warning: MessageRecordWarning) => void;
+}
+export interface RewriteMessageRecordOptions {
+    root: string;
+    messagesFilePath: string;
+    sessionId: string;
+    mutate: (record: MessageRecord) => MessageRecord;
+    forceFlush?: boolean;
+}
+export interface AppendMessageRecordOptions {
+    root: string;
+    messagesFilePath: string;
+    record: MessageRecord;
+}
+export declare function readMessageRecords(options: ReadMessageRecordsOptions): Promise<MessageRecord[]>;
+export declare function appendMessageRecord(options: AppendMessageRecordOptions): Promise<void>;
+export declare function rewriteMessageRecord(options: RewriteMessageRecordOptions): Promise<MessageRecord>;
+export declare function flushMessageRecordBuffer(options: {
+    messagesFilePath: string;
+    sessionId: string;
+}): Promise<void>;
+export declare function flushAllMessageRecordBuffers(): Promise<void>;

package/dist/domain/message/persistence/adapter.js

@@ -0,0 +1,124 @@
+import { dirname, join } from "node:path";
+import { mapSessionStoreError, sessionStoreErrorMapper, } from "../../../persistence/error-mapping.js";
+import { SessionRecordParseError } from "../../../persistence/errors.js";
+import { acquireHistoryLock } from "../../../persistence/history-lock.js";
+import { createSessionStore, } from "../../../persistence/session-store.js";
+import { messageRecordSchema, TERMINAL_MESSAGE_STATUSES, } from "../model/types.js";
+const MESSAGE_INDEX_VERSION = 1;
+const MESSAGE_RECORD_FILENAME = "record.json";
+const MESSAGE_HISTORY_LOCK_FILENAME = "history.lock";
+const messagePersistence = createSessionStore({
+    recordFilename: MESSAGE_RECORD_FILENAME,
+    indexVersion: MESSAGE_INDEX_VERSION,
+    acquireLock: acquireHistoryLock,
+    parseRecord: ({ path, raw }) => {
+        const parsed = JSON.parse(raw);
+        const result = messageRecordSchema.safeParse(parsed);
+        if (!result.success) {
+            const issues = result.error.issues
+                .map((issue) => issue.message)
+                .join(", ");
+            throw new SessionRecordParseError(path, issues);
+        }
+        return result.data;
+    },
+    buildIndexEntry: (record) => ({
+        sessionId: record.sessionId,
+        createdAt: record.createdAt,
+        status: record.status,
+    }),
+    getIndexEntryId: (entry) => entry.sessionId,
+    shouldForceFlush: (record) => TERMINAL_MESSAGE_STATUSES.includes(record.status),
+    getRecordId: (record) => record.sessionId,
+    getRecordStatus: (record) => record.status,
+    readIndexEntries: (parsed) => {
+        const payload = parsed;
+        return Array.isArray(payload.sessions) ? payload.sessions : [];
+    },
+});
+export async function readMessageRecords(options) {
+    const { root, messagesFilePath, limit, predicate, onWarning } = options;
+    const paths = buildMessagePaths(root, messagesFilePath);
+    try {
+        return await messagePersistence.readRecords({
+            paths,
+            limit,
+            predicate,
+            onWarning: onWarning
+                ? (warning) => onWarning(mapWarning(warning))
+                : undefined,
+        });
+    }
+    catch (error) {
+        throw mapSessionStoreError(error, sessionStoreErrorMapper);
+    }
+}
+export async function appendMessageRecord(options) {
+    const { root, messagesFilePath, record } = options;
+    const paths = buildMessagePaths(root, messagesFilePath);
+    try {
+        await messagePersistence.appendRecord({ paths, record });
+    }
+    catch (error) {
+        throw mapSessionStoreError(error, sessionStoreErrorMapper);
+    }
+}
+export async function rewriteMessageRecord(options) {
+    const { root, messagesFilePath, sessionId, mutate, forceFlush = false, } = options;
+    const paths = buildMessagePaths(root, messagesFilePath);
+    try {
+        return await messagePersistence.rewriteRecord({
+            paths,
+            sessionId,
+            mutate,
+            forceFlush,
+        });
+    }
+    catch (error) {
+        throw mapSessionStoreError(error, sessionStoreErrorMapper);
+    }
+}
+export async function flushMessageRecordBuffer(options) {
+    const { messagesFilePath, sessionId } = options;
+    const paths = buildMessagePaths("", messagesFilePath);
+    try {
+        await messagePersistence.flushRecordBuffer({ paths, sessionId });
+    }
+    catch (error) {
+        throw mapSessionStoreError(error, sessionStoreErrorMapper);
+    }
+}
+export async function flushAllMessageRecordBuffers() {
+    try {
+        await messagePersistence.flushAllRecordBuffers();
+    }
+    catch (error) {
+        throw mapSessionStoreError(error, sessionStoreErrorMapper);
+    }
+}
+function buildMessagePaths(root, messagesFilePath) {
+    const messagesRoot = dirname(messagesFilePath);
+    return {
+        root,
+        indexPath: messagesFilePath,
+        sessionsDir: join(messagesRoot, "sessions"),
+        lockPath: join(messagesRoot, MESSAGE_HISTORY_LOCK_FILENAME),
+    };
+}
+function mapWarning(warning) {
+    if (warning.kind === "parse-error") {
+        return {
+            kind: "parse-error",
+            sessionId: warning.sessionId,
+            recordPath: warning.recordPath,
+            displayPath: warning.displayPath,
+            details: warning.details,
+        };
+    }
+    return {
+        kind: "missing-record",
+        sessionId: warning.sessionId,
+        recordPath: warning.recordPath,
+        displayPath: warning.displayPath,
+    };
+}

package/dist/domain/reduce/competition/adapter.d.ts

@@ -31,6 +31,7 @@ export interface CreateReduceCompetitionAdapterInput {
     readonly reductionsFilePath: string;
     readonly specsFilePath: string;
     readonly runsFilePath: string;
+    readonly messagesFilePath: string;
     readonly verificationsFilePath: string;
     readonly target: ReductionTarget;
     readonly environment: EnvironmentConfig;

package/dist/domain/reduce/competition/adapter.js

@@ -7,6 +7,7 @@ import { RunNotFoundCliError } from "../../../cli/errors.js";
 import { stageExtraContextFiles, } from "../../../competition/shared/extra-context.js";
 import { composeStageSandboxPolicy } from "../../../competition/shared/sandbox-policy.js";
 import { createTeardownController, runTeardown, } from "../../../competition/shared/teardown.js";
+import { readMessageRecords } from "../../../domain/message/persistence/adapter.js";
 import { validateReductionOutputContract } from "../../../domain/reduce/competition/output-validation.js";
 import { buildReducePrompt } from "../../../domain/reduce/competition/prompt.js";
 import { parseReductionArtifact } from "../../../domain/reduce/competition/reduction.js";
@@ -25,9 +26,9 @@ import { normalizePathForDisplay, relativeToRoot, resolvePath, } from "../../../
 import { extractProviderNativeTokenUsageForSession } from "../../../workspace/chat/native-usage.js";
 import { scaffoldAgentSessionWorkspace, } from "../../../workspace/layout.js";
 import { promoteWorkspaceFile } from "../../../workspace/promotion.js";
-import { REDUCTION_ARTIFACT_INFO_FILENAME, REDUCTION_DATA_FILENAME, REDUCTION_FILENAME, VORATIQ_REDUCTION_DIR, } from "../../../workspace/structure.js";
+import { MESSAGE_RESPONSE_FILENAME, REDUCTION_ARTIFACT_INFO_FILENAME, REDUCTION_DATA_FILENAME, REDUCTION_FILENAME, VORATIQ_REDUCTION_DIR, } from "../../../workspace/structure.js";
 export function createReduceCompetitionAdapter(input) {
-    const { root, reductionId, createdAt, reductionsFilePath, specsFilePath, runsFilePath, verificationsFilePath, target, environment, extraContextFiles = [], renderer, } = input;
+    const { root, reductionId, createdAt, reductionsFilePath, specsFilePath, runsFilePath, messagesFilePath, verificationsFilePath, target, environment, extraContextFiles = [], renderer, } = input;
     let failure;
     const teardown = createTeardownController(`reduce \`${reductionId}\``);
     teardown.addAction({
@@ -55,6 +56,7 @@ export function createReduceCompetitionAdapter(input) {
                 root,
                 specsFilePath,
                 runsFilePath,
+                messagesFilePath,
                 verificationsFilePath,
                 reductionsFilePath,
                 target,
@@ -443,10 +445,12 @@ async function prepareReductionTargetContext(options) {
             return await prepareSpecTargetContext(options);
         case "run":
             return await prepareRunTargetContext(options);
-        case "verify":
-            return await prepareVerificationTargetContext(options);
         case "reduce":
             return await prepareReductionTargetContextInternal(options);
+        case "verify":
+            return await prepareVerificationTargetContext(options);
+        case "message":
+            return await prepareMessageTargetContext(options);
     }
 }
 async function prepareSpecTargetContext(options) {
@@ -682,6 +686,55 @@ async function prepareReductionTargetContextInternal(options) {
         },
     };
 }
+async function prepareMessageTargetContext(options) {
+    const { root, messagesFilePath, target } = options;
+    const [record] = await readMessageRecords({
+        root,
+        messagesFilePath,
+        limit: 1,
+        predicate: (entry) => entry.sessionId === target.id,
+    });
+    if (!record) {
+        throw new Error(`Message session \`${target.id}\` not found.`);
+    }
+    const succeededRecipients = record.recipients.filter((recipient) => recipient.status === "succeeded" &&
+        typeof recipient.outputPath === "string");
+    if (succeededRecipients.length === 0) {
+        throw new Error(`Message session \`${target.id}\` has no generated artifacts.`);
+    }
+    const stagedFiles = [];
+    const artifacts = [];
+    for (const recipient of succeededRecipients) {
+        const outputRelative = `inputs/recipients/${recipient.agentId}/${MESSAGE_RESPONSE_FILENAME}`;
+        stagedFiles.push({
+            sourceAbsolutePath: resolvePath(root, recipient.outputPath),
+            stagedRelativePath: outputRelative,
+        });
+        artifacts.push({
+            artifactId: `message:${recipient.agentId}`,
+            kind: "message-output",
+            agentId: recipient.agentId,
+            status: recipient.status,
+            outputPath: outputRelative,
+            ...(recipient.tokenUsage ? { tokenUsage: recipient.tokenUsage } : {}),
+        });
+    }
+    return {
+        target,
+        displayPath: `.voratiq/message/sessions/${record.sessionId}`,
+        stagedFiles,
+        manifest: {
+            target: {
+                operator: "message",
+                id: record.sessionId,
+                path: `.voratiq/message/sessions/${record.sessionId}`,
+                status: record.status,
+                prompt: record.prompt,
+            },
+            artifacts,
+        },
+    };
+}
 async function stageReductionTargetContext(options) {
     const { workspacePath, targetContext } = options;
     for (const stagedFile of targetContext.stagedFiles) {

package/dist/domain/reduce/competition/prompt.d.ts

@@ -1,6 +1,6 @@
 import { type ResolvedExtraContextFile } from "../../../competition/shared/extra-context.js";
 export interface BuildReducePromptOptions {
-    targetOperator: "spec" | "run" | "verify" | "reduce";
+    targetOperator: "spec" | "run" | "reduce" | "verify" | "message";
     targetId: string;
     artifactInfoPath: string;
     repoRootPath: string;

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

@@ -3,6 +3,7 @@ import { type ReductionStatus, reductionStatusSchema, TERMINAL_REDUCTION_STATUSE
 export type { ReductionStatus };
 export { reductionStatusSchema, TERMINAL_REDUCTION_STATUSES };
 export declare const reductionTargetTypeSchema: z.ZodEnum<{
+    message: "message";
     reduce: "reduce";
     spec: "spec";
     run: "run";
@@ -11,6 +12,7 @@ export declare const reductionTargetTypeSchema: z.ZodEnum<{
 export type ReductionTargetType = z.infer<typeof reductionTargetTypeSchema>;
 export declare const reductionTargetSchema: z.ZodObject<{
     type: z.ZodEnum<{
+        message: "message";
         reduce: "reduce";
         spec: "spec";
         run: "run";
@@ -57,6 +59,7 @@ export declare const reductionRecordSchema: z.ZodObject<{
     sessionId: z.ZodString;
     target: z.ZodObject<{
         type: z.ZodEnum<{
+            message: "message";
             reduce: "reduce";
             spec: "spec";
             run: "run";

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

@@ -9,8 +9,9 @@ export { reductionStatusSchema, TERMINAL_REDUCTION_STATUSES };
 export const reductionTargetTypeSchema = z.enum([
     "spec",
     "run",
-    "verify",
     "reduce",
+    "verify",
+    "message",
 ]);
 export const reductionTargetSchema = z
     .object({

package/dist/domain/verify/competition/adapter.js

@@ -17,7 +17,7 @@ import { verificationResultArtifactSchema, } from "../model/types.js";
 import { writeVerificationArtifact } from "./artifacts.js";
 import { assertNoVerificationIdentityLeak, assertRubricResultSelectorsMatchAliasMap, buildForbiddenVerificationIdentityTokens, parseRubricResultPayload, } from "./blinding.js";
 import { buildRubricPrompt } from "./prompt.js";
-import { attachVerifierWorkspaceMounts, buildStagedVerificationInputs, } from "./shared-layout.js";
+import { attachVerifierWorkspaceMounts, buildStagedVerificationInputs, sharedInputsUseReferenceRepo, } from "./shared-layout.js";
 export function createVerifyCompetitionAdapter(input) {
     const { root, verificationId, resolvedTarget, aliasMap, environment, extraContextFiles, sharedInputs, teardown, mutators, renderer, } = input;
     const startedAtByExecutionKey = new Map();
@@ -94,8 +94,7 @@ export function createVerifyCompetitionAdapter(input) {
             await attachVerifierWorkspaceMounts({
                 workspacePath: workspacePaths.workspacePath,
                 contextPath: workspacePaths.contextPath,
-                sharedInputsAbsolute: sharedInputs.sharedInputsAbsolute,
-                referenceRepoAbsolute: sharedInputs.referenceRepoAbsolute,
+                sharedInputs,
             });
             await ensureWorkspaceDependencies({
                 root,
@@ -131,9 +130,13 @@ export function createVerifyCompetitionAdapter(input) {
                     workspacePaths.contextPath,
                     join(workspacePaths.workspacePath, "context"),
                     join(workspacePaths.workspacePath, "inputs"),
-                    join(workspacePaths.workspacePath, "reference_repo"),
                     sharedInputs.sharedInputsAbsolute,
-                    sharedInputs.referenceRepoAbsolute,
+                    ...(sharedInputsUseReferenceRepo(sharedInputs)
+                        ? [
+                            join(workspacePaths.workspacePath, "reference_repo"),
+                            sharedInputs.referenceRepoAbsolute,
+                        ]
+                        : []),
                 ],
             });
             const result = await runSandboxedAgent({

package/dist/domain/verify/competition/programmatic.js

@@ -277,6 +277,9 @@ function resolveProgrammaticMethodPlan(options) {
             checks,
         };
     }
+    if (resolvedTarget.target.kind === "message") {
+        return { kind: "none" };
+    }
     const configuredChecks = extractUnsupportedProgrammaticChecks(resolvedTarget.target.kind === "spec"
         ? verificationConfig.spec
         : verificationConfig.reduce);

package/dist/domain/verify/competition/prompt.js

@@ -38,6 +38,12 @@ export function buildRubricPrompt(options) {
             return `  - ${candidate.alias}${suffix}`;
         }));
     }
+    else if (staged.kind === "message") {
+        lines.push(`- Original message prompt: \`${staged.promptPath}\``, "- Candidate responses:", ...staged.candidates.map((candidate) => `  - ${candidate.alias}: \`${candidate.responsePath}\``));
+    }
+    else if (staged.kind === "reduce-no-reference") {
+        lines.push(`- No repository snapshot is available for this reduction target because its lineage reaches message session \`${staged.referenceRepoUnavailable.messageSessionId}\` without a durable base revision.`, "- Reduction candidates:", ...staged.candidates.map((candidate) => `  - ${candidate.alias}: \`${candidate.reductionPath}\``));
+    }
     else {
         lines.push(`- Base repository snapshot (read-only): \`${staged.referenceRepoPath}/\``, "- Reduction candidates:", ...staged.candidates.map((candidate) => `  - ${candidate.alias}: \`${candidate.reductionPath}\``));
     }

package/dist/domain/verify/competition/rubric.js

@@ -8,7 +8,13 @@ export async function executeAndPersistRubricMethods(options) {
         ? verificationConfig.spec.rubric
         : resolvedTarget.target.kind === "run"
             ? verificationConfig.run.rubric
-            : verificationConfig.reduce.rubric;
+            : resolvedTarget.target.kind === "reduce"
+                ? verificationConfig.reduce.rubric
+                : verificationConfig.message.rubric;
+    if (resolvedTarget.target.kind === "message" &&
+        rubricTemplates.length === 0) {
+        throw new Error("Message verification requires at least one configured rubric template under `message.rubric` in `.voratiq/verification.yaml`.");
+    }
     if (rubricTemplates.length === 0 || verifierAgents.length === 0) {
         return [];
     }

package/dist/domain/verify/competition/shared-layout.d.ts

@@ -31,6 +31,27 @@ export type SharedVerificationInputs = {
     candidates: readonly {
         alias: string;
     }[];
+} | {
+    kind: "reduce-no-reference";
+    sharedRootAbsolute: string;
+    sharedInputsAbsolute: string;
+    worktreesToRemove: readonly string[];
+    referenceRepoUnavailable: {
+        reason: "message-lineage";
+        messageSessionId: string;
+    };
+    candidates: readonly {
+        alias: string;
+    }[];
+} | {
+    kind: "message";
+    sharedRootAbsolute: string;
+    sharedInputsAbsolute: string;
+    worktreesToRemove: readonly string[];
+    promptAbsolute: string;
+    candidates: readonly {
+        alias: string;
+    }[];
 };
 export type StagedVerificationInputs = {
     kind: "spec";
@@ -57,6 +78,23 @@ export type StagedVerificationInputs = {
         alias: string;
         reductionPath: string;
     }[];
+} | {
+    kind: "reduce-no-reference";
+    referenceRepoUnavailable: {
+        reason: "message-lineage";
+        messageSessionId: string;
+    };
+    candidates: readonly {
+        alias: string;
+        reductionPath: string;
+    }[];
+} | {
+    kind: "message";
+    promptPath: string;
+    candidates: readonly {
+        alias: string;
+        responsePath: string;
+    }[];
 };
 export declare function prepareSharedVerificationInputs(options: {
     root: string;
@@ -73,9 +111,11 @@ export declare function buildStagedVerificationInputs(options: {
     workspacePaths: AgentWorkspacePaths;
     sharedInputs: SharedVerificationInputs;
 }): StagedVerificationInputs;
+export declare function sharedInputsUseReferenceRepo(sharedInputs: SharedVerificationInputs): sharedInputs is Extract<SharedVerificationInputs, {
+    kind: "spec" | "run" | "reduce";
+}>;
 export declare function attachVerifierWorkspaceMounts(options: {
     workspacePath: string;
     contextPath: string;
-    sharedInputsAbsolute: string;
-    referenceRepoAbsolute: string;
+    sharedInputs: SharedVerificationInputs;
 }): Promise<void>;