voratiq 0.1.0-beta.2 → 0.1.0-beta.21

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

@@ -0,0 +1,144 @@
+import { mkdir } from "node:fs/promises";
+import { relative as relativePath } 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 { assertRepoRelativePath, resolvePath } from "../../../utils/path.js";
+import { getInteractiveHistoryLockPath, getInteractiveIndexPath, getInteractiveSessionArtifactsDirectoryPath, getInteractiveSessionDirectoryPath, getInteractiveSessionRecordPath, getInteractiveSessionsDirectoryPath, } from "../../../workspace/structure.js";
+import { interactiveSessionIndexRecordSchema, interactiveSessionRecordSchema, } from "../model/types.js";
+const INTERACTIVE_INDEX_VERSION = 1;
+const interactivePersistence = createSessionStore({
+    recordFilename: "record.json",
+    indexVersion: INTERACTIVE_INDEX_VERSION,
+    acquireLock: acquireHistoryLock,
+    parseRecord: ({ path, raw }) => parseInteractiveRecord(path, raw),
+    buildIndexEntry: (record) => ({
+        sessionId: record.sessionId,
+        createdAt: record.createdAt,
+        status: record.status,
+    }),
+    getIndexEntryId: (entry) => entry.sessionId,
+    shouldForceFlush: (record) => record.status !== "running",
+    getRecordId: (record) => record.sessionId,
+    getRecordStatus: (record) => record.status,
+    readIndexEntries: (parsed) => {
+        const result = interactiveSessionIndexRecordSchema.safeParse(parsed);
+        return result.success ? result.data.sessions : [];
+    },
+});
+export function resolveInteractiveSessionPaths(root, sessionId) {
+    return {
+        indexPath: resolvePath(root, getInteractiveIndexPath()),
+        sessionRoot: resolvePath(root, getInteractiveSessionDirectoryPath(sessionId)),
+        recordPath: resolvePath(root, getInteractiveSessionRecordPath(sessionId)),
+        artifactsPath: resolvePath(root, getInteractiveSessionArtifactsDirectoryPath(sessionId)),
+        runtimePath: resolvePath(root, getInteractiveSessionDirectoryPath(sessionId), "runtime"),
+    };
+}
+export async function ensureInteractiveSessionDirectories(options) {
+    const { sessionRoot, artifactsPath, runtimePath } = options;
+    await Promise.all([
+        mkdir(sessionRoot, { recursive: true }),
+        mkdir(artifactsPath, { recursive: true }),
+        mkdir(runtimePath, { recursive: true }),
+    ]);
+}
+export async function appendInteractiveSessionRecord(options) {
+    const { root, record } = options;
+    const paths = buildInteractiveSessionStorePaths(root);
+    try {
+        await interactivePersistence.appendRecord({ paths, record });
+    }
+    catch (error) {
+        throw mapSessionStoreError(error, sessionStoreErrorMapper);
+    }
+}
+export async function rewriteInteractiveSessionRecord(options) {
+    const { root, sessionId, mutate, forceFlush = true } = options;
+    const paths = buildInteractiveSessionStorePaths(root);
+    try {
+        return await interactivePersistence.rewriteRecord({
+            paths,
+            sessionId,
+            mutate,
+            forceFlush,
+        });
+    }
+    catch (error) {
+        throw mapSessionStoreError(error, sessionStoreErrorMapper);
+    }
+}
+export async function updateInteractiveSessionStatus(options) {
+    const { root, sessionId, status } = options;
+    return await rewriteInteractiveSessionRecord({
+        root,
+        sessionId,
+        mutate: (record) => ({
+            ...record,
+            status,
+        }),
+        forceFlush: true,
+    });
+}
+export async function getInteractiveSessionRecordSnapshot(options) {
+    const paths = buildInteractiveSessionStorePaths(options.root);
+    try {
+        return await interactivePersistence.getRecordSnapshot({
+            paths,
+            sessionId: options.sessionId,
+        });
+    }
+    catch (error) {
+        throw mapSessionStoreError(error, sessionStoreErrorMapper);
+    }
+}
+export async function flushAllInteractiveSessionBuffers() {
+    try {
+        await interactivePersistence.flushAllRecordBuffers();
+    }
+    catch (error) {
+        throw mapSessionStoreError(error, sessionStoreErrorMapper);
+    }
+}
+export async function disposeInteractiveSessionBuffer(options) {
+    const paths = buildInteractiveSessionStorePaths(options.root);
+    try {
+        await interactivePersistence.disposeRecordBuffer({
+            paths,
+            sessionId: options.sessionId,
+        });
+    }
+    catch (error) {
+        throw mapSessionStoreError(error, sessionStoreErrorMapper);
+    }
+}
+export function toInteractiveSessionRelativePath(root, absolutePath) {
+    if (!absolutePath) {
+        return undefined;
+    }
+    const relative = relativePath(root, absolutePath).replaceAll("\\", "/");
+    return assertRepoRelativePath(relative);
+}
+function buildInteractiveSessionStorePaths(root) {
+    return {
+        root,
+        indexPath: resolvePath(root, getInteractiveIndexPath()),
+        sessionsDir: resolvePath(root, getInteractiveSessionsDirectoryPath()),
+        lockPath: resolvePath(root, getInteractiveHistoryLockPath()),
+    };
+}
+function parseInteractiveRecord(path, raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new SessionRecordParseError(path, error instanceof Error ? error.message : "Invalid JSON");
+    }
+    const result = interactiveSessionRecordSchema.safeParse(parsed);
+    if (!result.success) {
+        throw new SessionRecordParseError(path, result.error.issues.map((issue) => issue.message).join(", "));
+    }
+    return result.data;
+}

package/dist/domain/interactive/prompt.d.ts

@@ -0,0 +1,3 @@
+import type { ToolAttachmentStatus } from "./model/types.js";
+export declare const FIRST_PARTY_ATTACHED_LAUNCH_PROMPT: "Context only. Do not respond to this message unless asked. Voratiq MCP tools are attached in this repo. For Voratiq session history and workflow actions, prefer the Voratiq MCP tools over bash, search, or direct file reads.";
+export declare function resolveFirstPartyLaunchPrompt(toolAttachmentStatus: ToolAttachmentStatus): string | undefined;

package/dist/domain/interactive/prompt.js

@@ -0,0 +1,7 @@
+export const FIRST_PARTY_ATTACHED_LAUNCH_PROMPT = "Context only. Do not respond to this message unless asked. Voratiq MCP tools are attached in this repo. For Voratiq session history and workflow actions, prefer the Voratiq MCP tools over bash, search, or direct file reads.";
+export function resolveFirstPartyLaunchPrompt(toolAttachmentStatus) {
+    if (toolAttachmentStatus !== "attached") {
+        return undefined;
+    }
+    return FIRST_PARTY_ATTACHED_LAUNCH_PROMPT;
+}

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

@@ -0,0 +1,36 @@
+import type { CompetitionCommandAdapter } from "../../../competition/command-adapter.js";
+import { type ResolvedExtraContextFile } from "../../../competition/shared/extra-context.js";
+import { type TeardownController } from "../../../competition/shared/teardown.js";
+import type { AgentDefinition } from "../../../configs/agents/types.js";
+import type { EnvironmentConfig } from "../../../configs/environment/types.js";
+import type { TokenUsageResult } from "../../../workspace/chat/token-usage-result.js";
+import { type AgentWorkspacePaths } from "../../../workspace/layout.js";
+import type { ExtractedTokenUsage } from "../../run/model/types.js";
+export type MessageCompetitionCandidate = AgentDefinition;
+export interface MessageCompetitionExecution {
+    readonly agentId: string;
+    readonly status: "succeeded" | "failed";
+    readonly startedAt: string;
+    readonly completedAt: string;
+    readonly outputPath?: string;
+    readonly stdoutPath: string;
+    readonly stderrPath: string;
+    readonly tokenUsage?: ExtractedTokenUsage;
+    readonly tokenUsageResult: TokenUsageResult;
+    readonly error?: string;
+}
+interface PreparedMessageCompetitionCandidate {
+    readonly candidate: MessageCompetitionCandidate;
+    readonly workspacePaths: AgentWorkspacePaths;
+    readonly prompt: string;
+}
+export interface CreateMessageCompetitionAdapterInput {
+    readonly root: string;
+    readonly messageId: string;
+    readonly prompt: string;
+    readonly environment: EnvironmentConfig;
+    readonly extraContextFiles?: readonly ResolvedExtraContextFile[];
+    readonly teardown?: TeardownController;
+}
+export declare function createMessageCompetitionAdapter(input: CreateMessageCompetitionAdapterInput): CompetitionCommandAdapter<MessageCompetitionCandidate, PreparedMessageCompetitionCandidate, MessageCompetitionExecution>;
+export {};

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

@@ -0,0 +1,197 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { detectAgentProcessFailureDetail } from "../../../agents/runtime/failures.js";
+import { runSandboxedAgent } from "../../../agents/runtime/harness.js";
+import { teardownSessionAuth } from "../../../agents/runtime/registry.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 { buildUnavailableTokenUsageResult, resolveTokenUsage, } from "../../../domain/shared/token-usage.js";
+import { toErrorMessage } from "../../../utils/errors.js";
+import { normalizePathForDisplay, relativeToRoot, resolvePath, } from "../../../utils/path.js";
+import { extractProviderNativeTokenUsageForSession } from "../../../workspace/chat/native-usage.js";
+import { scaffoldAgentSessionWorkspace, } from "../../../workspace/layout.js";
+import { promoteWorkspaceFile } from "../../../workspace/promotion.js";
+import { MESSAGE_RESPONSE_FILENAME, VORATIQ_MESSAGE_DIR, } from "../../../workspace/structure.js";
+import { buildMessagePrompt } from "./prompt.js";
+export function createMessageCompetitionAdapter(input) {
+    const { root, messageId, prompt, environment, extraContextFiles = [], teardown: providedTeardown, } = input;
+    const teardown = providedTeardown ?? createTeardownController(`message \`${messageId}\``);
+    const ownsTeardown = providedTeardown === undefined;
+    teardown.addAction({
+        key: `message-auth:${messageId}`,
+        label: "session auth",
+        cleanup: async () => {
+            await teardownSessionAuth(messageId);
+        },
+    });
+    return {
+        failurePolicy: "continue",
+        prepareCandidates: async (candidates) => {
+            const ready = [];
+            const failures = [];
+            for (const candidate of candidates) {
+                const startedAt = new Date().toISOString();
+                try {
+                    const workspacePaths = await scaffoldAgentSessionWorkspace({
+                        root,
+                        domain: VORATIQ_MESSAGE_DIR,
+                        sessionId: messageId,
+                        agentId: candidate.id,
+                    });
+                    registerScratchWorkspaceTeardown(teardown, workspacePaths, candidate.id);
+                    await stageExtraContextFiles({
+                        contextPath: workspacePaths.contextPath,
+                        files: extraContextFiles,
+                    });
+                    const builtPrompt = buildMessagePrompt({
+                        prompt,
+                        repoRootPath: root,
+                        workspacePath: workspacePaths.workspacePath,
+                        extraContextFiles,
+                    });
+                    ready.push({
+                        candidate,
+                        workspacePaths,
+                        prompt: builtPrompt,
+                    });
+                }
+                catch (error) {
+                    const completedAt = new Date().toISOString();
+                    failures.push({
+                        agentId: candidate.id,
+                        status: "failed",
+                        startedAt,
+                        completedAt,
+                        stdoutPath: buildStdoutDisplayPath(root, messageId, candidate.id),
+                        stderrPath: buildStderrDisplayPath(root, messageId, candidate.id),
+                        tokenUsageResult: buildUnavailableTokenUsageResult({
+                            provider: candidate.provider,
+                            modelId: candidate.model,
+                            message: toErrorMessage(error),
+                        }),
+                        error: toErrorMessage(error),
+                    });
+                }
+            }
+            return { ready, failures };
+        },
+        executeCandidate: async (prepared) => {
+            const { candidate, workspacePaths, prompt: builtPrompt } = prepared;
+            const startedAt = new Date().toISOString();
+            try {
+                const result = await runSandboxedAgent({
+                    root,
+                    sessionId: messageId,
+                    sandboxStageId: "message",
+                    agent: candidate,
+                    prompt: builtPrompt,
+                    environment,
+                    paths: {
+                        agentRoot: workspacePaths.agentRoot,
+                        workspacePath: workspacePaths.workspacePath,
+                        sandboxHomePath: workspacePaths.sandboxHomePath,
+                        runtimeManifestPath: workspacePaths.runtimeManifestPath,
+                        sandboxSettingsPath: workspacePaths.sandboxSettingsPath,
+                        runtimePath: workspacePaths.runtimePath,
+                        artifactsPath: workspacePaths.artifactsPath,
+                        stdoutPath: workspacePaths.stdoutPath,
+                        stderrPath: workspacePaths.stderrPath,
+                    },
+                    captureChat: true,
+                    teardownAuthOnExit: false,
+                    ...composeStageSandboxPolicy(),
+                });
+                const tokenUsageResult = await extractProviderNativeTokenUsageForSession({
+                    root,
+                    domain: VORATIQ_MESSAGE_DIR,
+                    sessionId: messageId,
+                    agentId: candidate.id,
+                    provider: candidate.provider,
+                    modelId: candidate.model,
+                    chatCaptured: result.chat?.captured === true,
+                    format: result.chat?.format,
+                    artifactPath: result.chat?.artifactPath,
+                });
+                const tokenUsage = resolveTokenUsage(tokenUsageResult);
+                if (result.exitCode !== 0 || result.errorMessage) {
+                    const detail = (await detectAgentProcessFailureDetail({
+                        provider: candidate.provider,
+                        stdoutPath: workspacePaths.stdoutPath,
+                        stderrPath: workspacePaths.stderrPath,
+                    })) ??
+                        result.errorMessage ??
+                        `Agent exited with code ${result.exitCode ?? "unknown"}`;
+                    return {
+                        agentId: candidate.id,
+                        status: "failed",
+                        startedAt,
+                        completedAt: new Date().toISOString(),
+                        stdoutPath: normalizePathForDisplay(relativeToRoot(root, workspacePaths.stdoutPath)),
+                        stderrPath: normalizePathForDisplay(relativeToRoot(root, workspacePaths.stderrPath)),
+                        tokenUsage,
+                        tokenUsageResult,
+                        error: detail,
+                    };
+                }
+                const stagedResponsePath = join(workspacePaths.workspacePath, MESSAGE_RESPONSE_FILENAME);
+                await readFile(stagedResponsePath, "utf8");
+                const responsePromoteResult = await promoteWorkspaceFile({
+                    workspacePath: workspacePaths.workspacePath,
+                    artifactsPath: workspacePaths.artifactsPath,
+                    stagedRelativePath: MESSAGE_RESPONSE_FILENAME,
+                    artifactRelativePath: MESSAGE_RESPONSE_FILENAME,
+                    deleteStaged: true,
+                });
+                return {
+                    agentId: candidate.id,
+                    status: "succeeded",
+                    startedAt,
+                    completedAt: new Date().toISOString(),
+                    outputPath: normalizePathForDisplay(relativeToRoot(root, responsePromoteResult.artifactPath)),
+                    stdoutPath: normalizePathForDisplay(relativeToRoot(root, workspacePaths.stdoutPath)),
+                    stderrPath: normalizePathForDisplay(relativeToRoot(root, workspacePaths.stderrPath)),
+                    tokenUsage,
+                    tokenUsageResult,
+                };
+            }
+            catch (error) {
+                return {
+                    agentId: candidate.id,
+                    status: "failed",
+                    startedAt,
+                    completedAt: new Date().toISOString(),
+                    stdoutPath: normalizePathForDisplay(relativeToRoot(root, workspacePaths.stdoutPath)),
+                    stderrPath: normalizePathForDisplay(relativeToRoot(root, workspacePaths.stderrPath)),
+                    tokenUsageResult: buildUnavailableTokenUsageResult({
+                        provider: candidate.provider,
+                        modelId: candidate.model,
+                        message: toErrorMessage(error),
+                    }),
+                    error: toErrorMessage(error),
+                };
+            }
+        },
+        finalizeCompetition: async () => {
+            if (ownsTeardown) {
+                await runTeardown(teardown);
+            }
+        },
+        sortResults: compareMessageExecutionsByAgentId,
+    };
+}
+function registerScratchWorkspaceTeardown(teardown, workspacePaths, agentId) {
+    teardown.addPath(workspacePaths.workspacePath, `${agentId} workspace`);
+    teardown.addPath(workspacePaths.contextPath, `${agentId} context`);
+    teardown.addPath(workspacePaths.runtimePath, `${agentId} runtime`);
+    teardown.addPath(workspacePaths.sandboxPath, `${agentId} sandbox`);
+}
+function compareMessageExecutionsByAgentId(left, right) {
+    return left.agentId.localeCompare(right.agentId);
+}
+function buildStdoutDisplayPath(root, messageId, agentId) {
+    return normalizePathForDisplay(relativeToRoot(root, resolvePath(root, `.voratiq/message/sessions/${messageId}/${agentId}/artifacts/stdout.log`)));
+}
+function buildStderrDisplayPath(root, messageId, agentId) {
+    return normalizePathForDisplay(relativeToRoot(root, resolvePath(root, `.voratiq/message/sessions/${messageId}/${agentId}/artifacts/stderr.log`)));
+}

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

@@ -0,0 +1,8 @@
+import { type ResolvedExtraContextFile } from "../../../competition/shared/extra-context.js";
+export interface BuildMessagePromptOptions {
+    prompt: string;
+    repoRootPath: string;
+    workspacePath: string;
+    extraContextFiles?: readonly ResolvedExtraContextFile[];
+}
+export declare function buildMessagePrompt(options: BuildMessagePromptOptions): string;

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

@@ -0,0 +1,29 @@
+import { appendExtraContextPromptSection, } from "../../../competition/shared/extra-context.js";
+import { appendConstraints, appendOutputRequirements, buildWorkspaceArtifactRequirements, } from "../../../competition/shared/prompt-helpers.js";
+export function buildMessagePrompt(options) {
+    const { prompt, repoRootPath, workspacePath, extraContextFiles = [], } = options;
+    const lines = [
+        "Respond to the prompt below using the available repository context.",
+        "",
+        "Guidance:",
+        "- Inspect the repository directly when needed.",
+        "- Keep the response focused on the prompt.",
+        "",
+        "Prompt:",
+        "```",
+        prompt.trim(),
+        "```",
+    ];
+    appendConstraints(lines, {
+        readAccess: repoRootPath,
+        writeAccess: workspacePath,
+    });
+    appendExtraContextPromptSection(lines, extraContextFiles);
+    appendOutputRequirements(lines, buildWorkspaceArtifactRequirements([
+        {
+            instruction: "Write the response",
+            path: "response.md",
+        },
+    ], ["- `response.md` is required."]));
+    return `${lines.join("\n")}\n`;
+}

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

@@ -0,0 +1,17 @@
+import type { MessageRecipientEntry, MessageRecord, MessageStatus } from "./types.js";
+export interface MessageRecordMutators {
+    recordRecipientQueued: (recipient: MessageRecipientEntry) => Promise<void>;
+    recordRecipientRunning: (recipient: MessageRecipientEntry) => Promise<void>;
+    recordRecipientSnapshot: (recipient: MessageRecipientEntry) => Promise<void>;
+    completeMessage: (options: {
+        status: MessageStatus;
+        error?: string | null;
+    }) => Promise<MessageRecord>;
+    readRecord: () => Promise<MessageRecord | undefined>;
+}
+export interface CreateMessageRecordMutatorsInput {
+    readonly root: string;
+    readonly messagesFilePath: string;
+    readonly messageId: string;
+}
+export declare function createMessageRecordMutators(input: CreateMessageRecordMutatorsInput): MessageRecordMutators;

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

@@ -0,0 +1,107 @@
+import { buildLifecycleStartFields, buildRecordLifecycleCompleteFields, } from "../../shared/lifecycle.js";
+import { rewriteMessageRecord } from "../persistence/adapter.js";
+export function createMessageRecordMutators(input) {
+    const { root, messagesFilePath, messageId } = input;
+    return {
+        recordRecipientQueued: async (recipient) => {
+            await updateRecipient({
+                root,
+                messagesFilePath,
+                messageId,
+                recipient,
+            });
+        },
+        recordRecipientRunning: async (recipient) => {
+            await updateRecipient({
+                root,
+                messagesFilePath,
+                messageId,
+                recipient,
+            });
+        },
+        recordRecipientSnapshot: async (recipient) => {
+            await updateRecipient({
+                root,
+                messagesFilePath,
+                messageId,
+                recipient,
+                forceFlush: recipient.status === "succeeded" ||
+                    recipient.status === "failed" ||
+                    recipient.status === "aborted",
+            });
+        },
+        completeMessage: async ({ status, error }) => await rewriteMessageRecord({
+            root,
+            messagesFilePath,
+            sessionId: messageId,
+            mutate: (existing) => ({
+                ...existing,
+                status,
+                ...buildRecordLifecycleCompleteFields({ existing }),
+                ...(error !== undefined ? { error } : {}),
+            }),
+            forceFlush: true,
+        }),
+        readRecord: async () => await rewriteMessageRecord({
+            root,
+            messagesFilePath,
+            sessionId: messageId,
+            mutate: (record) => record,
+        }),
+    };
+}
+async function updateRecipient(options) {
+    const { root, messagesFilePath, messageId, recipient, forceFlush = false, } = options;
+    await rewriteMessageRecord({
+        root,
+        messagesFilePath,
+        sessionId: messageId,
+        forceFlush,
+        mutate: (existing) => {
+            const recipients = [...existing.recipients];
+            const index = recipients.findIndex((entry) => entry.agentId === recipient.agentId);
+            const current = index >= 0 ? recipients[index] : undefined;
+            const merged = mergeRecipientEntries(current, recipient);
+            if (index >= 0) {
+                recipients[index] = merged;
+            }
+            else {
+                recipients.push(merged);
+            }
+            return {
+                ...existing,
+                status: existing.status === "running" || merged.status !== "running"
+                    ? existing.status
+                    : "running",
+                ...(merged.startedAt
+                    ? buildLifecycleStartFields({
+                        existingStartedAt: existing.startedAt,
+                        timestamp: merged.startedAt,
+                    })
+                    : {}),
+                recipients,
+            };
+        },
+    });
+}
+function mergeRecipientEntries(existing, incoming) {
+    if (existing &&
+        isTerminalRecipientStatus(existing.status) &&
+        !isTerminalRecipientStatus(incoming.status)) {
+        return existing;
+    }
+    return {
+        ...(existing ?? {}),
+        ...incoming,
+        outputPath: incoming.outputPath ?? existing?.outputPath,
+        stdoutPath: incoming.stdoutPath ?? existing?.stdoutPath,
+        stderrPath: incoming.stderrPath ?? existing?.stderrPath,
+        tokenUsage: incoming.tokenUsage ?? existing?.tokenUsage,
+        error: incoming.error !== undefined ? incoming.error : (existing?.error ?? null),
+        startedAt: incoming.startedAt ?? existing?.startedAt,
+        completedAt: incoming.completedAt ?? existing?.completedAt,
+    };
+}
+function isTerminalRecipientStatus(status) {
+    return status === "succeeded" || status === "failed" || status === "aborted";
+}

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;