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

package/dist/commands/verify/targets.js

@@ -1,4 +1,7 @@
+import { basename } from "node:path";
 import { CliError, RunNotFoundCliError } from "../../cli/errors.js";
+import { TERMINAL_MESSAGE_STATUSES } from "../../domain/message/model/types.js";
+import { readMessageRecords } from "../../domain/message/persistence/adapter.js";
 import { TERMINAL_REDUCTION_STATUSES } from "../../domain/reduce/model/types.js";
 import { readReductionRecords } from "../../domain/reduce/persistence/adapter.js";
 import { RunRecordNotFoundError } from "../../domain/run/model/errors.js";
@@ -7,6 +10,7 @@ import { TERMINAL_SPEC_STATUSES } from "../../domain/spec/model/types.js";
 import { readSpecRecords } from "../../domain/spec/persistence/adapter.js";
 import { readVerificationRecords } from "../../domain/verify/persistence/adapter.js";
 import { TERMINAL_RUN_STATUSES } from "../../status/index.js";
+import { MESSAGE_RESPONSE_FILENAME } from "../../workspace/structure.js";
 export async function resolveVerifyTarget(input) {
     const { target } = input;
     switch (target.kind) {
@@ -16,6 +20,8 @@ export async function resolveVerifyTarget(input) {
             return resolveRunVerifyTarget(input);
         case "reduce":
             return resolveReductionVerifyTarget(input);
+        case "message":
+            return resolveMessageVerifyTarget(input);
     }
 }
 async function resolveSpecVerifyTarget(input) {
@@ -111,22 +117,76 @@ async function resolveReductionVerifyTarget(input) {
     if (!TERMINAL_REDUCTION_STATUSES.includes(record.status)) {
         throw new CliError(`Reduction session \`${target.sessionId}\` is not complete.`, [`Status: \`${record.status}\`.`], ["Wait for the reduction to finish before running `voratiq verify`."]);
     }
-    return {
-        baseRevisionSha: await resolveReductionBaseRevisionSha({
-            ...input,
+    const referenceRepo = await resolveReductionReferenceRepo({
+        ...input,
+        reductionRecord: record,
+    });
+    const competitiveCandidates = record.reducers
+        .filter((reducer) => reducer.status === "succeeded" && reducer.outputPath)
+        .map((reducer) => ({
+        canonicalId: reducer.agentId,
+        forbiddenIdentityTokens: [reducer.agentId],
+    }));
+    if (referenceRepo.kind === "git") {
+        return {
+            baseRevisionSha: referenceRepo.baseRevisionSha,
+            competitiveCandidates,
+            target: {
+                kind: "reduce",
+                sessionId: record.sessionId,
+            },
             reductionRecord: record,
-        }),
-        competitiveCandidates: record.reducers
-            .filter((reducer) => reducer.status === "succeeded" && reducer.outputPath)
-            .map((reducer) => ({
-            canonicalId: reducer.agentId,
-            forbiddenIdentityTokens: [reducer.agentId],
-        })),
+        };
+    }
+    return {
+        competitiveCandidates,
         target: {
             kind: "reduce",
             sessionId: record.sessionId,
         },
         reductionRecord: record,
+        referenceRepoUnavailable: {
+            reason: "message-lineage",
+            messageSessionId: referenceRepo.messageSessionId,
+        },
+    };
+}
+async function resolveMessageVerifyTarget(input) {
+    const { root, messagesFilePath, target } = input;
+    const [record] = await readMessageRecords({
+        root,
+        messagesFilePath,
+        limit: 1,
+        predicate: (entry) => entry.sessionId === target.sessionId,
+    });
+    if (!record) {
+        throw new CliError(`Message session \`${target.sessionId}\` not found.`, [], [
+            "Re-run `voratiq message` or confirm the session id in `.voratiq/message/index.json`.",
+        ]);
+    }
+    if (!TERMINAL_MESSAGE_STATUSES.includes(record.status)) {
+        throw new CliError(`Message session \`${target.sessionId}\` is not complete.`, [`Status: \`${record.status}\`.`], [
+            "Wait for the message session to finish before running `voratiq verify`.",
+        ]);
+    }
+    const recipients = resolveVerifiableMessageRecipients(record);
+    if (recipients.length === 0) {
+        throw new CliError(`Message session \`${target.sessionId}\` has no verifiable message responses.`, [
+            "Verification requires at least one succeeded recipient with a durable `response.md` artifact.",
+        ], [
+            "Re-run `voratiq message` to capture at least one succeeded response before running `voratiq verify`.",
+        ]);
+    }
+    return {
+        competitiveCandidates: recipients.map((recipient) => ({
+            canonicalId: recipient.agentId,
+            forbiddenIdentityTokens: [recipient.agentId],
+        })),
+        target: {
+            kind: "message",
+            sessionId: record.sessionId,
+        },
+        messageRecord: record,
     };
 }
 function collectRunCandidateIdentityTokens(options) {
@@ -144,8 +204,8 @@ function collectRunCandidateIdentityTokens(options) {
     }
     return Array.from(tokens);
 }
-async function resolveReductionBaseRevisionSha(options) {
-    const { root, specsFilePath, runsFilePath, reductionsFilePath, verificationsFilePath, reductionRecord, seenReductionIds = new Set(), } = options;
+async function resolveReductionReferenceRepo(options) {
+    const { root, specsFilePath, runsFilePath, reductionsFilePath, messagesFilePath, verificationsFilePath, reductionRecord, seenReductionIds = new Set(), } = options;
     if (seenReductionIds.has(reductionRecord.sessionId)) {
         throw new CliError(`Reduction session \`${reductionRecord.sessionId}\` has a recursive target chain.`, [], [
             "Inspect `.voratiq/reduce/index.json` and repair the reduction target metadata.",
@@ -163,9 +223,12 @@ async function resolveReductionBaseRevisionSha(options) {
             if (!record) {
                 throw new CliError(`Spec session \`${reductionRecord.target.id}\` referenced by reduction \`${reductionRecord.sessionId}\` was not found.`);
             }
-            return resolveSpecBaseRevisionSha(record, {
-                ownerLabel: `reduction \`${reductionRecord.sessionId}\``,
-            });
+            return {
+                kind: "git",
+                baseRevisionSha: resolveSpecBaseRevisionSha(record, {
+                    ownerLabel: `reduction \`${reductionRecord.sessionId}\``,
+                }),
+            };
         }
         case "run": {
             const { records } = await fetchRunsSafely({
@@ -183,7 +246,10 @@ async function resolveReductionBaseRevisionSha(options) {
             if (!runRecord) {
                 throw new RunNotFoundCliError(reductionRecord.target.id);
             }
-            return runRecord.baseRevisionSha;
+            return {
+                kind: "git",
+                baseRevisionSha: runRecord.baseRevisionSha,
+            };
         }
         case "verify": {
             const [verificationRecord] = await readVerificationRecords({
@@ -212,7 +278,10 @@ async function resolveReductionBaseRevisionSha(options) {
                     if (!runRecord) {
                         throw new RunNotFoundCliError(verificationRecord.target.sessionId);
                     }
-                    return runRecord.baseRevisionSha;
+                    return {
+                        kind: "git",
+                        baseRevisionSha: runRecord.baseRevisionSha,
+                    };
                 }
                 case "spec": {
                     const [record] = await readSpecRecords({
@@ -224,9 +293,12 @@ async function resolveReductionBaseRevisionSha(options) {
                     if (!record) {
                         throw new CliError(`Spec session \`${verificationRecord.target.sessionId}\` referenced by verification \`${verificationRecord.sessionId}\` was not found.`);
                     }
-                    return resolveSpecBaseRevisionSha(record, {
-                        ownerLabel: `verification \`${verificationRecord.sessionId}\``,
-                    });
+                    return {
+                        kind: "git",
+                        baseRevisionSha: resolveSpecBaseRevisionSha(record, {
+                            ownerLabel: `verification \`${verificationRecord.sessionId}\``,
+                        }),
+                    };
                 }
                 case "reduce": {
                     const [parentReduction] = await readReductionRecords({
@@ -238,16 +310,37 @@ async function resolveReductionBaseRevisionSha(options) {
                     if (!parentReduction) {
                         throw new CliError(`Reduction session \`${verificationRecord.target.sessionId}\` referenced by verification \`${verificationRecord.sessionId}\` was not found.`);
                     }
-                    return await resolveReductionBaseRevisionSha({
+                    return await resolveReductionReferenceRepo({
                         root,
                         specsFilePath,
                         runsFilePath,
                         reductionsFilePath,
+                        messagesFilePath,
                         verificationsFilePath,
                         reductionRecord: parentReduction,
                         seenReductionIds,
                     });
                 }
+                case "message": {
+                    const [messageRecord] = await readMessageRecords({
+                        root,
+                        messagesFilePath,
+                        limit: 1,
+                        predicate: (entry) => entry.sessionId === verificationRecord.target.sessionId,
+                    });
+                    if (!messageRecord) {
+                        throw new CliError(`Message session \`${verificationRecord.target.sessionId}\` referenced by verification \`${verificationRecord.sessionId}\` was not found.`);
+                    }
+                    return messageRecord.baseRevisionSha
+                        ? {
+                            kind: "git",
+                            baseRevisionSha: messageRecord.baseRevisionSha,
+                        }
+                        : {
+                            kind: "none",
+                            messageSessionId: messageRecord.sessionId,
+                        };
+                }
             }
             throw new CliError(`Verification session \`${verificationRecord.sessionId}\` references an unsupported target kind.`);
         }
@@ -261,18 +354,57 @@ async function resolveReductionBaseRevisionSha(options) {
             if (!parentReduction) {
                 throw new CliError(`Reduction session \`${reductionRecord.target.id}\` referenced by reduction \`${reductionRecord.sessionId}\` was not found.`);
             }
-            return await resolveReductionBaseRevisionSha({
+            return await resolveReductionReferenceRepo({
                 root,
                 specsFilePath,
                 runsFilePath,
                 reductionsFilePath,
+                messagesFilePath,
                 verificationsFilePath,
                 reductionRecord: parentReduction,
                 seenReductionIds,
             });
         }
+        case "message": {
+            const [messageRecord] = await readMessageRecords({
+                root,
+                messagesFilePath,
+                limit: 1,
+                predicate: (entry) => entry.sessionId === reductionRecord.target.id,
+            });
+            if (!messageRecord) {
+                throw new CliError(`Message session \`${reductionRecord.target.id}\` referenced by reduction \`${reductionRecord.sessionId}\` was not found.`);
+            }
+            return messageRecord.baseRevisionSha
+                ? {
+                    kind: "git",
+                    baseRevisionSha: messageRecord.baseRevisionSha,
+                }
+                : {
+                    kind: "none",
+                    messageSessionId: messageRecord.sessionId,
+                };
+        }
     }
 }
+function resolveVerifiableMessageRecipients(record) {
+    return record.recipients.flatMap((recipient) => {
+        if (recipient.status !== "succeeded" ||
+            typeof recipient.outputPath !== "string" ||
+            !isCanonicalMessageResponseArtifact(recipient.outputPath)) {
+            return [];
+        }
+        return [
+            {
+                agentId: recipient.agentId,
+                outputPath: recipient.outputPath,
+            },
+        ];
+    });
+}
+function isCanonicalMessageResponseArtifact(outputPath) {
+    return basename(outputPath) === MESSAGE_RESPONSE_FILENAME;
+}
 function resolveSpecBaseRevisionSha(record, options = {}) {
     if (record.baseRevisionSha) {
         return record.baseRevisionSha;

package/dist/configs/agents/defaults.js

@@ -129,28 +129,6 @@ const DEFAULT_AGENT_CATALOG_ENTRIES = [
         model: "gpt-5.2",
         extraArgs: ["--config", "model_reasoning_effort=xhigh"],
     },
-    {
-        id: "gpt-5-4-mini",
-        provider: "codex",
-        model: "gpt-5.4-mini",
-    },
-    {
-        id: "gpt-5-4",
-        provider: "codex",
-        model: "gpt-5.4",
-    },
-    {
-        id: "gpt-5-4-high",
-        provider: "codex",
-        model: "gpt-5.4",
-        extraArgs: ["--config", "model_reasoning_effort=high"],
-    },
-    {
-        id: "gpt-5-4-xhigh",
-        provider: "codex",
-        model: "gpt-5.4",
-        extraArgs: ["--config", "model_reasoning_effort=xhigh"],
-    },
     {
         id: "gpt-5-2-codex",
         provider: "codex",
@@ -191,15 +169,37 @@ const DEFAULT_AGENT_CATALOG_ENTRIES = [
         extraArgs: ["--config", "model_reasoning_effort=xhigh"],
     },
     {
-        id: "gemini-2-5-flash-lite",
-        provider: "gemini",
-        model: "gemini-2.5-flash-lite",
+        id: "gpt-5-4-mini",
+        provider: "codex",
+        model: "gpt-5.4-mini",
+    },
+    {
+        id: "gpt-5-4",
+        provider: "codex",
+        model: "gpt-5.4",
+    },
+    {
+        id: "gpt-5-4-high",
+        provider: "codex",
+        model: "gpt-5.4",
+        extraArgs: ["--config", "model_reasoning_effort=high"],
+    },
+    {
+        id: "gpt-5-4-xhigh",
+        provider: "codex",
+        model: "gpt-5.4",
+        extraArgs: ["--config", "model_reasoning_effort=xhigh"],
     },
     {
         id: "gemini-2-5-flash",
         provider: "gemini",
         model: "gemini-2.5-flash",
     },
+    {
+        id: "gemini-2-5-flash-lite",
+        provider: "gemini",
+        model: "gemini-2.5-flash-lite",
+    },
     {
         id: "gemini-3-flash-preview",
         provider: "gemini",

package/dist/configs/orchestration/bootstrap.d.ts

@@ -4,8 +4,13 @@ export interface ResolvedPresetAgent {
     readonly id: string;
     readonly runOnly?: true;
 }
+export interface BootstrapOrchestrationProfiles {
+    readonly default: readonly ResolvedPresetAgent[];
+    readonly pro: readonly ResolvedPresetAgent[];
+    readonly lite: readonly ResolvedPresetAgent[];
+}
 export declare function collectEnabledAgentIdsForBootstrap(agents: readonly Pick<AgentConfigEntry, "id" | "enabled">[]): string[];
-export declare function serializeDefaultOrchestrationYaml(presetAgents: readonly ResolvedPresetAgent[]): string;
+export declare function serializeDefaultOrchestrationYaml(profiles: BootstrapOrchestrationProfiles): string;
 export declare function listEnabledAgentIdsForOrchestrationBootstrap(config: AgentsConfig): string[];
 export declare function listPresetStageAgentsForOrchestrationBootstrap(config: AgentsConfig, preset: AgentPreset): ResolvedPresetAgent[];
 export declare function buildDefaultOrchestrationTemplate(config: AgentsConfig, preset?: AgentPreset): string;

package/dist/configs/orchestration/bootstrap.js

@@ -4,7 +4,9 @@ const ORCHESTRATION_BOOTSTRAP_STAGE_IDS = [
     "run",
     "reduce",
     "verify",
+    "message",
 ];
+const ORCHESTRATION_BOOTSTRAP_PRESET_PROFILES = ["pro", "lite"];
 export function collectEnabledAgentIdsForBootstrap(agents) {
     const seen = new Set();
     const enabledAgentIds = [];
@@ -20,8 +22,23 @@ export function collectEnabledAgentIdsForBootstrap(agents) {
     }
     return enabledAgentIds;
 }
-export function serializeDefaultOrchestrationYaml(presetAgents) {
-    const lines = ["profiles:", "  default:"];
+export function serializeDefaultOrchestrationYaml(profiles) {
+    const lines = ["profiles:"];
+    const profileNames = [
+        "default",
+        ...ORCHESTRATION_BOOTSTRAP_PRESET_PROFILES,
+    ];
+    for (const [index, profileName] of profileNames.entries()) {
+        if (index > 0) {
+            lines.push("");
+        }
+        appendProfileYaml(lines, profileName, profiles[profileName]);
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+function appendProfileYaml(lines, profileName, presetAgents) {
+    lines.push(`  ${profileName}:`);
     for (const stageId of ORCHESTRATION_BOOTSTRAP_STAGE_IDS) {
         lines.push(`    ${stageId}:`);
         const agents = stageId === "run" ? presetAgents : presetAgents.filter((a) => !a.runOnly);
@@ -35,8 +52,6 @@ export function serializeDefaultOrchestrationYaml(presetAgents) {
             }
         }
     }
-    lines.push("");
-    return lines.join("\n");
 }
 function formatYamlScalar(value) {
     if (/^[a-z0-9_-]{1,64}$/u.test(value)) {
@@ -96,6 +111,12 @@ function hasBinary(binary) {
     return typeof binary === "string" && binary.trim().length > 0;
 }
 export function buildDefaultOrchestrationTemplate(config, preset = "pro") {
-    const stageAgents = listPresetStageAgentsForOrchestrationBootstrap(config, preset);
-    return serializeDefaultOrchestrationYaml(stageAgents);
+    const proAgents = listPresetStageAgentsForOrchestrationBootstrap(config, "pro");
+    const liteAgents = listPresetStageAgentsForOrchestrationBootstrap(config, "lite");
+    const defaultAgents = preset === "lite" ? liteAgents : preset === "manual" ? [] : proAgents;
+    return serializeDefaultOrchestrationYaml({
+        default: defaultAgents,
+        pro: proAgents,
+        lite: liteAgents,
+    });
 }

package/dist/configs/orchestration/types.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-export declare const ORCHESTRATION_STAGE_IDS: readonly ["run", "verify", "spec", "reduce"];
+export declare const ORCHESTRATION_STAGE_IDS: readonly ["spec", "run", "reduce", "verify", "message"];
 export type OrchestrationStageId = (typeof ORCHESTRATION_STAGE_IDS)[number];
 export declare const orchestrationStageAgentSchema: z.ZodObject<{
     id: z.ZodString;
@@ -12,17 +12,17 @@ export declare const orchestrationStageSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type OrchestrationStageConfig = z.infer<typeof orchestrationStageSchema>;
 export declare const orchestrationProfileSchema: z.ZodObject<{
-    reduce: z.ZodObject<{
+    spec: z.ZodObject<{
         agents: z.ZodArray<z.ZodObject<{
             id: z.ZodString;
         }, z.core.$strict>>;
     }, z.core.$strict>;
-    spec: z.ZodObject<{
+    run: z.ZodObject<{
         agents: z.ZodArray<z.ZodObject<{
             id: z.ZodString;
         }, z.core.$strict>>;
     }, z.core.$strict>;
-    run: z.ZodObject<{
+    reduce: z.ZodObject<{
         agents: z.ZodArray<z.ZodObject<{
             id: z.ZodString;
         }, z.core.$strict>>;
@@ -32,23 +32,28 @@ export declare const orchestrationProfileSchema: z.ZodObject<{
             id: z.ZodString;
         }, z.core.$strict>>;
     }, z.core.$strict>;
+    message: z.ZodDefault<z.ZodObject<{
+        agents: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export type OrchestrationProfile = z.infer<typeof orchestrationProfileSchema>;
 export declare const ORCHESTRATION_PROFILE_NAME_PATTERN: RegExp;
 export declare const ORCHESTRATION_PROFILE_NAME_MAX_LENGTH = 64;
 export declare const orchestrationProfileNameSchema: z.ZodString;
 export declare const orchestrationProfilesSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
-    reduce: z.ZodObject<{
+    spec: z.ZodObject<{
         agents: z.ZodArray<z.ZodObject<{
             id: z.ZodString;
         }, z.core.$strict>>;
     }, z.core.$strict>;
-    spec: z.ZodObject<{
+    run: z.ZodObject<{
         agents: z.ZodArray<z.ZodObject<{
             id: z.ZodString;
         }, z.core.$strict>>;
     }, z.core.$strict>;
-    run: z.ZodObject<{
+    reduce: z.ZodObject<{
         agents: z.ZodArray<z.ZodObject<{
             id: z.ZodString;
         }, z.core.$strict>>;
@@ -58,21 +63,26 @@ export declare const orchestrationProfilesSchema: z.ZodRecord<z.ZodString, z.Zod
             id: z.ZodString;
         }, z.core.$strict>>;
     }, z.core.$strict>;
+    message: z.ZodDefault<z.ZodObject<{
+        agents: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
 }, z.core.$strict>>;
 export type OrchestrationProfiles = z.infer<typeof orchestrationProfilesSchema>;
 export declare const orchestrationConfigSchema: z.ZodObject<{
     profiles: z.ZodRecord<z.ZodString, z.ZodObject<{
-        reduce: z.ZodObject<{
+        spec: z.ZodObject<{
             agents: z.ZodArray<z.ZodObject<{
                 id: z.ZodString;
             }, z.core.$strict>>;
         }, z.core.$strict>;
-        spec: z.ZodObject<{
+        run: z.ZodObject<{
             agents: z.ZodArray<z.ZodObject<{
                 id: z.ZodString;
             }, z.core.$strict>>;
         }, z.core.$strict>;
-        run: z.ZodObject<{
+        reduce: z.ZodObject<{
             agents: z.ZodArray<z.ZodObject<{
                 id: z.ZodString;
             }, z.core.$strict>>;
@@ -82,6 +92,11 @@ export declare const orchestrationConfigSchema: z.ZodObject<{
                 id: z.ZodString;
             }, z.core.$strict>>;
         }, z.core.$strict>;
+        message: z.ZodDefault<z.ZodObject<{
+            agents: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export type OrchestrationConfig = z.infer<typeof orchestrationConfigSchema>;

package/dist/configs/orchestration/types.js

@@ -1,10 +1,11 @@
 import { z } from "zod";
 import { agentIdSchema } from "../agents/types.js";
 export const ORCHESTRATION_STAGE_IDS = [
-    "run",
-    "verify",
     "spec",
+    "run",
     "reduce",
+    "verify",
+    "message",
 ];
 export const orchestrationStageAgentSchema = z
     .object({
@@ -30,10 +31,13 @@ export const orchestrationStageSchema = z
         seen.add(agent.id);
     });
 });
-const orchestrationProfileShape = {};
-for (const stageId of ORCHESTRATION_STAGE_IDS) {
-    orchestrationProfileShape[stageId] = orchestrationStageSchema;
-}
+const orchestrationProfileShape = {
+    spec: orchestrationStageSchema,
+    run: orchestrationStageSchema,
+    reduce: orchestrationStageSchema,
+    verify: orchestrationStageSchema,
+    message: orchestrationStageSchema.default({ agents: [] }),
+};
 export const orchestrationProfileSchema = z
     .object(orchestrationProfileShape)
     .strict();

package/dist/configs/verification/types.d.ts

@@ -39,6 +39,11 @@ export declare const verificationConfigSchema: z.ZodObject<{
             template: z.ZodString;
         }, z.core.$strict>>>>;
     }, z.core.$strict>>>;
+    message: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        rubric: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            template: z.ZodString;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>>>;
 }, z.core.$strict>;
 export type VerificationConfig = z.infer<typeof verificationConfigSchema>;
 export {};

package/dist/configs/verification/types.js

@@ -38,5 +38,8 @@ export const verificationConfigSchema = z
     reduce: verificationRubricOnlyStageConfigSchema
         .optional()
         .default({ rubric: [] }),
+    message: verificationRubricOnlyStageConfigSchema
+        .optional()
+        .default({ rubric: [] }),
 })
     .strict();