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

package/dist/commands/message/command.js

@@ -0,0 +1,215 @@
+import { verifyAgentProviders } from "../../agents/runtime/auth.js";
+import { executeCompetitionWithAdapter } from "../../competition/command-adapter.js";
+import { createTeardownController } from "../../competition/shared/teardown.js";
+import { AgentNotFoundError } from "../../configs/agents/errors.js";
+import { loadEnvironmentConfig } from "../../configs/environment/loader.js";
+import { createMessageCompetitionAdapter, } from "../../domain/message/competition/adapter.js";
+import { createMessageRecordMutators } from "../../domain/message/model/mutators.js";
+import { deriveMessageStatusFromRecipients, } from "../../domain/message/model/types.js";
+import { appendMessageRecord, flushMessageRecordBuffer, } from "../../domain/message/persistence/adapter.js";
+import { buildPersistedExtraContextFields } from "../../extra-context/contract.js";
+import { toErrorMessage } from "../../utils/errors.js";
+import { getHeadRevision } from "../../utils/git.js";
+import { VORATIQ_MESSAGE_DIR, VORATIQ_REDUCTION_DIR, VORATIQ_RUN_DIR, VORATIQ_SPEC_DIR, VORATIQ_VERIFICATION_DIR, } from "../../workspace/structure.js";
+import { resolveEffectiveMaxParallel } from "../shared/max-parallel.js";
+import { resolveStageCompetitors } from "../shared/resolve-stage-competitors.js";
+import { generateSessionId } from "../shared/session-id.js";
+import { MessageAgentNotFoundError, MessageGenerationFailedError, MessageInvocationContextError, } from "./errors.js";
+import { finalizeActiveMessage, registerActiveMessage } from "./lifecycle.js";
+export async function executeMessageCommand(input) {
+    assertMessageInvocationContext();
+    const { root, messagesFilePath, prompt, agentIds, agentOverrideFlag, profileName, maxParallel: requestedMaxParallel, extraContextFiles = [], sourceInteractiveSessionId, renderer, } = input;
+    let competitors;
+    try {
+        const resolution = resolveStageCompetitors({
+            root,
+            stageId: "message",
+            cliAgentIds: agentIds,
+            cliOverrideFlag: agentOverrideFlag,
+            profileName,
+        });
+        competitors = resolution.competitors;
+    }
+    catch (error) {
+        if (error instanceof AgentNotFoundError) {
+            throw new MessageAgentNotFoundError(error.agentId);
+        }
+        throw error;
+    }
+    await assertMessagePreflight(competitors);
+    const environment = loadEnvironmentConfig({ root });
+    const baseRevisionSha = await getHeadRevision(root);
+    const messageId = generateSessionId();
+    const createdAt = new Date().toISOString();
+    const startedAt = createdAt;
+    const effectiveMaxParallel = resolveEffectiveMaxParallel({
+        competitorCount: competitors.length,
+        requestedMaxParallel,
+    });
+    const initialRecipients = competitors.map((agent) => ({
+        agentId: agent.id,
+        status: "queued",
+    }));
+    await appendMessageRecord({
+        root,
+        messagesFilePath,
+        record: {
+            sessionId: messageId,
+            createdAt,
+            startedAt,
+            status: "running",
+            baseRevisionSha,
+            prompt,
+            recipients: initialRecipients,
+            ...buildPersistedExtraContextFields(extraContextFiles),
+            ...(sourceInteractiveSessionId ? { sourceInteractiveSessionId } : {}),
+        },
+    });
+    renderer?.begin({
+        messageId,
+        createdAt,
+        startedAt,
+        workspacePath: `.voratiq/message/sessions/${messageId}`,
+        status: "running",
+    });
+    const teardown = createTeardownController(`message \`${messageId}\``);
+    registerActiveMessage({
+        root,
+        messagesFilePath,
+        messageId,
+        teardown,
+    });
+    const mutators = createMessageRecordMutators({
+        root,
+        messagesFilePath,
+        messageId,
+    });
+    let executions;
+    try {
+        const baseAdapter = createMessageCompetitionAdapter({
+            root,
+            messageId,
+            prompt,
+            environment,
+            extraContextFiles,
+            teardown,
+        });
+        executions = await executeCompetitionWithAdapter({
+            candidates: [...competitors],
+            maxParallel: effectiveMaxParallel,
+            adapter: {
+                ...baseAdapter,
+                onPreparationFailure: async (result) => {
+                    const recipient = toRecipientEntry(result);
+                    await mutators.recordRecipientSnapshot(recipient);
+                    renderer?.update(recipient);
+                },
+                onCandidateRunning: async (prepared) => {
+                    const runningAt = new Date().toISOString();
+                    const recipient = {
+                        agentId: prepared.candidate.id,
+                        status: "running",
+                        startedAt: runningAt,
+                    };
+                    await mutators.recordRecipientRunning(recipient);
+                    renderer?.update(recipient);
+                },
+                onCandidateCompleted: async (_prepared, result) => {
+                    const recipient = toRecipientEntry(result);
+                    await mutators.recordRecipientSnapshot(recipient);
+                    renderer?.update(recipient);
+                },
+            },
+        });
+        const persistedRecord = await mutators.readRecord();
+        if (!persistedRecord) {
+            throw new MessageGenerationFailedError([
+                `Message session \`${messageId}\` record not found after execution.`,
+            ]);
+        }
+        const status = deriveMessageStatusFromRecipients(persistedRecord.recipients.map((recipient) => recipient.status));
+        const completedRecord = await mutators.completeMessage({
+            status,
+            error: status === "failed"
+                ? collectRecipientErrors(persistedRecord.recipients)
+                : undefined,
+        });
+        await flushMessageRecordBuffer({
+            messagesFilePath,
+            sessionId: messageId,
+        });
+        renderer?.complete(completedRecord.status, {
+            startedAt: completedRecord.startedAt,
+            completedAt: completedRecord.completedAt,
+        });
+        return {
+            messageId,
+            record: completedRecord,
+            recipients: completedRecord.recipients,
+            executions,
+        };
+    }
+    catch (error) {
+        await mutators
+            .completeMessage({
+            status: "failed",
+            error: toErrorMessage(error),
+        })
+            .then((failedRecord) => {
+            renderer?.complete(failedRecord.status, {
+                startedAt: failedRecord.startedAt,
+                completedAt: failedRecord.completedAt,
+            });
+        })
+            .catch(() => {
+            renderer?.complete("failed");
+        });
+        await flushMessageRecordBuffer({
+            messagesFilePath,
+            sessionId: messageId,
+        }).catch(() => { });
+        throw new MessageGenerationFailedError([toErrorMessage(error)]);
+    }
+    finally {
+        await finalizeActiveMessage(messageId);
+    }
+}
+function toRecipientEntry(execution) {
+    return {
+        agentId: execution.agentId,
+        status: execution.status,
+        startedAt: execution.startedAt,
+        completedAt: execution.completedAt,
+        outputPath: execution.outputPath,
+        stdoutPath: execution.stdoutPath,
+        stderrPath: execution.stderrPath,
+        tokenUsage: execution.tokenUsage,
+        error: execution.error ?? null,
+    };
+}
+async function assertMessagePreflight(agents) {
+    const providerIssues = await verifyAgentProviders(agents.map((agent) => ({ id: agent.id, provider: agent.provider })));
+    if (providerIssues.length > 0) {
+        throw new MessageGenerationFailedError(providerIssues.map((issue) => `${issue.agentId}: ${issue.message}`));
+    }
+}
+function assertMessageInvocationContext() {
+    const cwd = process.cwd().replace(/\\/gu, "/");
+    const batchDomains = [
+        VORATIQ_SPEC_DIR,
+        VORATIQ_RUN_DIR,
+        VORATIQ_REDUCTION_DIR,
+        VORATIQ_VERIFICATION_DIR,
+        VORATIQ_MESSAGE_DIR,
+    ];
+    const batchWorkspacePattern = new RegExp(`/\\.voratiq/(?:${batchDomains.join("|")})/sessions/[^/]+/[^/]+/workspace(?:/|$)`, "u");
+    if (batchWorkspacePattern.test(cwd)) {
+        throw new MessageInvocationContextError();
+    }
+}
+function collectRecipientErrors(recipients) {
+    const details = recipients
+        .filter((recipient) => recipient.error)
+        .map((recipient) => `${recipient.agentId}: ${recipient.error}`);
+    return details.length > 0 ? details.join("; ") : undefined;
+}

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

@@ -0,0 +1,9 @@
+export declare class MessageAgentNotFoundError extends Error {
+    constructor(agentId: string);
+}
+export declare class MessageGenerationFailedError extends Error {
+    constructor(details: readonly string[]);
+}
+export declare class MessageInvocationContextError extends Error {
+    constructor();
+}

package/dist/commands/message/errors.js

@@ -0,0 +1,20 @@
+export class MessageAgentNotFoundError extends Error {
+    constructor(agentId) {
+        super(`Message agent not found: ${agentId}`);
+        this.name = "MessageAgentNotFoundError";
+    }
+}
+export class MessageGenerationFailedError extends Error {
+    constructor(details) {
+        super(details.length > 0
+            ? `Message execution failed: ${details.join("; ")}`
+            : "Message execution failed.");
+        this.name = "MessageGenerationFailedError";
+    }
+}
+export class MessageInvocationContextError extends Error {
+    constructor() {
+        super("`message` cannot be invoked from inside a batch agent workspace.");
+        this.name = "MessageInvocationContextError";
+    }
+}

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

@@ -0,0 +1,14 @@
+import type { TeardownController } from "../../competition/shared/teardown.js";
+export declare const MESSAGE_ABORT_DETAIL = "Message generation aborted before completion.";
+export declare const MESSAGE_FAILURE_DETAIL = "Message generation failed.";
+interface ActiveMessageContext {
+    root: string;
+    messagesFilePath: string;
+    messageId: string;
+    teardown?: TeardownController;
+}
+export declare function registerActiveMessage(context: ActiveMessageContext): void;
+export declare function clearActiveMessage(messageId: string): void;
+export declare function terminateActiveMessage(status: "failed" | "aborted"): Promise<void>;
+export declare function finalizeActiveMessage(messageId: string): Promise<void>;
+export {};

package/dist/commands/message/lifecycle.js

@@ -0,0 +1,128 @@
+import { runTeardown } from "../../competition/shared/teardown.js";
+import { flushMessageRecordBuffer, readMessageRecords, rewriteMessageRecord, } from "../../domain/message/persistence/adapter.js";
+import { buildOperationLifecycleCompleteFields, buildRecordLifecycleCompleteFields, } from "../../domain/shared/lifecycle.js";
+import { toErrorMessage } from "../../utils/errors.js";
+export const MESSAGE_ABORT_DETAIL = "Message generation aborted before completion.";
+export const MESSAGE_FAILURE_DETAIL = "Message generation failed.";
+let activeMessage;
+let terminationInFlight = false;
+export function registerActiveMessage(context) {
+    activeMessage = context;
+}
+export function clearActiveMessage(messageId) {
+    if (activeMessage?.messageId !== messageId) {
+        return;
+    }
+    if (!terminationInFlight) {
+        activeMessage = undefined;
+    }
+}
+export async function terminateActiveMessage(status) {
+    if (!activeMessage || terminationInFlight) {
+        return;
+    }
+    terminationInFlight = true;
+    const context = activeMessage;
+    let persistenceError;
+    try {
+        const existingRecord = await readMessageRecords({
+            root: context.root,
+            messagesFilePath: context.messagesFilePath,
+            limit: 1,
+            predicate: (record) => record.sessionId === context.messageId,
+        }).then((records) => records[0]);
+        if (!existingRecord) {
+            return;
+        }
+        const completedAt = new Date().toISOString();
+        const detail = status === "aborted" ? MESSAGE_ABORT_DETAIL : MESSAGE_FAILURE_DETAIL;
+        await rewriteMessageRecord({
+            root: context.root,
+            messagesFilePath: context.messagesFilePath,
+            sessionId: context.messageId,
+            mutate: (existing) => {
+                const recipients = existing.recipients.map((recipient) => finalizeMessageRecipient({
+                    recipient,
+                    status,
+                    completedAt,
+                    detail,
+                }));
+                const inProgress = existing.status === "queued" || existing.status === "running";
+                if (!inProgress) {
+                    if (recipients.every((recipient, index) => recipient === existing.recipients[index])) {
+                        return existing;
+                    }
+                    return {
+                        ...existing,
+                        recipients,
+                    };
+                }
+                return {
+                    ...existing,
+                    status,
+                    recipients,
+                    ...buildRecordLifecycleCompleteFields({
+                        existing,
+                        startedAt: existing.startedAt ?? completedAt,
+                        completedAt,
+                    }),
+                    error: existing.error ?? detail,
+                };
+            },
+            forceFlush: true,
+        });
+        await flushMessageRecordBuffer({
+            messagesFilePath: context.messagesFilePath,
+            sessionId: context.messageId,
+        });
+    }
+    catch (error) {
+        persistenceError =
+            error instanceof Error ? error : new Error(toErrorMessage(error));
+        console.error(`[voratiq] Failed to finalize message ${context.messageId}: ${toErrorMessage(error)}`);
+    }
+    finally {
+        try {
+            await finalizeRegisteredMessageTeardown(context);
+        }
+        finally {
+            terminationInFlight = false;
+            activeMessage = undefined;
+        }
+    }
+    if (persistenceError) {
+        throw persistenceError;
+    }
+}
+export async function finalizeActiveMessage(messageId) {
+    if (!activeMessage || activeMessage.messageId !== messageId) {
+        clearActiveMessage(messageId);
+        return;
+    }
+    const context = activeMessage;
+    try {
+        await finalizeRegisteredMessageTeardown(context);
+    }
+    finally {
+        clearActiveMessage(messageId);
+    }
+}
+function finalizeMessageRecipient(options) {
+    const { recipient, status, completedAt, detail } = options;
+    if (recipient.status !== "queued" && recipient.status !== "running") {
+        return recipient;
+    }
+    return {
+        ...recipient,
+        status,
+        ...buildOperationLifecycleCompleteFields({
+            existing: recipient,
+            startedAt: recipient.startedAt ?? completedAt,
+            completedAt,
+        }),
+        error: recipient.error ?? detail,
+    };
+}
+async function finalizeRegisteredMessageTeardown(context) {
+    await runTeardown(context.teardown);
+}

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

@@ -7,6 +7,7 @@ export interface ReduceCommandInput {
     specsFilePath: string;
     runsFilePath: string;
     reductionsFilePath: string;
+    messagesFilePath: string;
     verificationsFilePath: string;
     target: ReductionTarget;
     agentIds?: readonly string[];

package/dist/commands/reduce/command.js

@@ -11,12 +11,13 @@ import { generateSessionId } from "../shared/session-id.js";
 import { ReduceAgentNotFoundError, ReduceGenerationFailedError, ReducePreflightError, } from "./errors.js";
 import { assertReductionTargetEligible } from "./targets.js";
 export async function executeReduceCommand(input) {
-    const { root, specsFilePath, runsFilePath, reductionsFilePath, verificationsFilePath, target, agentIds, agentOverrideFlag, profileName, maxParallel: requestedMaxParallel, extraContextFiles = [], renderer, } = input;
+    const { root, specsFilePath, runsFilePath, reductionsFilePath, messagesFilePath, verificationsFilePath, target, agentIds, agentOverrideFlag, profileName, maxParallel: requestedMaxParallel, extraContextFiles = [], renderer, } = input;
     await assertReductionTargetEligible({
         root,
         specsFilePath,
         runsFilePath,
         reductionsFilePath,
+        messagesFilePath,
         verificationsFilePath,
         target,
     });
@@ -53,6 +54,7 @@ export async function executeReduceCommand(input) {
                 reductionsFilePath,
                 specsFilePath,
                 runsFilePath,
+                messagesFilePath,
                 verificationsFilePath,
                 target,
                 environment,

package/dist/commands/reduce/targets.d.ts

@@ -4,6 +4,7 @@ export interface ReductionTargetValidationInput {
     specsFilePath: string;
     runsFilePath: string;
     reductionsFilePath: string;
+    messagesFilePath: string;
     verificationsFilePath: string;
     target: ReductionTarget;
 }

package/dist/commands/reduce/targets.js

@@ -1,6 +1,8 @@
 import { dirname } from "node:path";
 import { CliError } from "../../cli/errors.js";
 import { 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 { buildRunRecordView } from "../../domain/run/model/enhanced.js";
@@ -23,11 +25,14 @@ export async function assertReductionTargetEligible(input) {
         case "run":
             await assertRunTargetEligible(input);
             return;
+        case "reduce":
+            await assertReductionTargetEligibleInternal(input);
+            return;
         case "verify":
             await assertVerificationTargetEligible(input);
             return;
-        case "reduce":
-            await assertReductionTargetEligibleInternal(input);
+        case "message":
+            await assertMessageTargetEligible(input);
             return;
     }
 }
@@ -162,6 +167,35 @@ async function assertReductionTargetEligibleInternal(input) {
         throw new CliError(`Reduction session \`${target.id}\` is missing required artifacts.`, missing.map((path) => `Missing: \`${path}\`.`), ["Re-run `voratiq reduce` to regenerate reduction artifacts."]);
     }
 }
+async function assertMessageTargetEligible(input) {
+    const { root, messagesFilePath, target } = input;
+    const [record] = await readMessageRecords({
+        root,
+        messagesFilePath,
+        limit: 1,
+        predicate: (entry) => entry.sessionId === target.id,
+    });
+    if (!record) {
+        throw new CliError(`Message session \`${target.id}\` 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.id}\` is not complete.`, [`Status: \`${record.status}\`.`], ["Wait for the message to finish before reducing."]);
+    }
+    if (record.status !== "succeeded") {
+        throw new CliError(`Message session \`${target.id}\` did not complete.`, [`Status: \`${record.status}\`.`], ["Re-run `voratiq message` to generate a complete artifact set."]);
+    }
+    const generatedRecipients = record.recipients.filter((recipient) => recipient.status === "succeeded" &&
+        typeof recipient.outputPath === "string");
+    if (generatedRecipients.length === 0) {
+        throw new CliError(`Message session \`${target.id}\` has no generated artifacts.`, [], ["Re-run `voratiq message` to regenerate the message artifacts."]);
+    }
+    const missing = await findMissingMessageArtifacts(root, generatedRecipients);
+    if (missing.length > 0) {
+        throw new CliError(`Message session \`${target.id}\` is missing required artifacts.`, missing.map((path) => `Missing: \`${path}\`.`), ["Re-run `voratiq message` to regenerate the message artifacts."]);
+    }
+}
 async function findMissingVerificationArtifacts(root, methods) {
     const missing = [];
     const seen = new Set();
@@ -195,6 +229,18 @@ async function findMissingReductionArtifacts(root, reducers) {
     }
     return missing;
 }
+async function findMissingMessageArtifacts(root, recipients) {
+    const missing = [];
+    const seen = new Set();
+    for (const recipient of recipients) {
+        const outputPath = recipient.outputPath;
+        const outputAbsolute = resolvePath(root, outputPath);
+        if (!(await pathExists(outputAbsolute))) {
+            registerMissing(missing, seen, outputPath);
+        }
+    }
+    return missing;
+}
 async function findMissingRunArtifacts(root, run) {
     const missing = [];
     const seen = new Set();

package/dist/commands/shared/resolve-stage-competitors.js

@@ -118,6 +118,9 @@ function assertResolvedAgentCount(options) {
         const configInstruction = enforceSingleCompetitor
             ? `Configure exactly one agent under \`${stageAgentsPath}\` in \`${ORCHESTRATION_CONFIG_DISPLAY_PATH}\`.`
             : `Configure at least one agent under \`${stageAgentsPath}\` in \`${ORCHESTRATION_CONFIG_DISPLAY_PATH}\`.`;
+        const overrideInstruction = enforceSingleCompetitor || stageId === "reduce"
+            ? []
+            : ["Or pass one or more `--agent` overrides."];
         throw new HintedError(missingAgentsHeadline(stageId), {
             detailLines: stageId === "reduce"
                 ? []
@@ -126,7 +129,7 @@ function assertResolvedAgentCount(options) {
                 ],
             hintLines: stageId === "reduce"
                 ? [configInstruction, "Or pass one or more `--agent` overrides."]
-                : [configInstruction],
+                : [configInstruction, ...overrideInstruction],
         });
     }
     if (!enforceSingleCompetitor || agentIds.length === 1) {

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

@@ -6,6 +6,7 @@ export interface VerifyCommandInput {
     specsFilePath: string;
     runsFilePath: string;
     reductionsFilePath: string;
+    messagesFilePath: string;
     verificationsFilePath: string;
     target: VerifyTargetSelection;
     agentIds?: readonly string[];

package/dist/commands/verify/command.js

@@ -18,12 +18,13 @@ import { finalizeActiveVerification, registerActiveVerification, } from "./lifec
 import { resolveVerifyRubricMaxParallel } from "./max-parallel.js";
 import { resolveVerifyTarget } from "./targets.js";
 export async function executeVerifyCommand(input) {
-    const { root, specsFilePath, runsFilePath, reductionsFilePath, verificationsFilePath, target, agentIds, agentOverrideFlag, profileName, maxParallel, extraContextFiles = [], renderer, } = input;
+    const { root, specsFilePath, runsFilePath, reductionsFilePath, messagesFilePath, verificationsFilePath, target, agentIds, agentOverrideFlag, profileName, maxParallel, extraContextFiles = [], renderer, } = input;
     const resolvedTarget = await resolveVerifyTarget({
         root,
         specsFilePath,
         runsFilePath,
         reductionsFilePath,
+        messagesFilePath,
         verificationsFilePath,
         target,
     });

package/dist/commands/verify/max-parallel.d.ts

@@ -1,6 +1,6 @@
 import type { VerificationConfig } from "../../configs/verification/types.js";
 export declare function resolveVerifyRubricMaxParallel(options: {
-    targetKind: "spec" | "run" | "reduce";
+    targetKind: "spec" | "run" | "reduce" | "message";
     verificationConfig: VerificationConfig;
     verifierAgentCount: number;
     requestedMaxParallel?: number;

package/dist/commands/verify/max-parallel.js

@@ -5,7 +5,9 @@ export function resolveVerifyRubricMaxParallel(options) {
         ? verificationConfig.spec.rubric.length
         : targetKind === "run"
             ? verificationConfig.run.rubric.length
-            : verificationConfig.reduce.rubric.length;
+            : targetKind === "reduce"
+                ? verificationConfig.reduce.rubric.length
+                : verificationConfig.message.rubric.length;
     return resolveEffectiveMaxParallel({
         competitorCount: verifierAgentCount * rubricTemplateCount,
         requestedMaxParallel,

package/dist/commands/verify/targets.d.ts

@@ -1,5 +1,5 @@
 import type { ResolvedVerificationTarget, VerificationCompetitiveCandidate } from "../../domain/verify/competition/target.js";
-export type VerifyTargetKind = "spec" | "run" | "reduce";
+export type VerifyTargetKind = "spec" | "run" | "reduce" | "message";
 export interface VerifyTargetSelection {
     kind: VerifyTargetKind;
     sessionId: string;
@@ -9,6 +9,7 @@ export interface ResolveVerifyTargetInput {
     specsFilePath: string;
     runsFilePath: string;
     reductionsFilePath: string;
+    messagesFilePath: string;
     verificationsFilePath: string;
     target: VerifyTargetSelection;
 }