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

package/dist/preflight/index.js

@@ -1,26 +1,61 @@
 import { isAbsolute, resolve } from "node:path";
-import { ensureFileExists } from "../utils/fs.js";
+import { executeInitCommand } from "../commands/init/command.js";
+import { ensureFileExists, pathExists } from "../utils/fs.js";
 import { assertGitRepository, runGitCommand, } from "../utils/git.js";
 import { relativeToRoot } from "../utils/path.js";
 import { collectMissingSandboxDependencies, formatSandboxDependencyList, } from "../workspace/sandbox-requirements.js";
-import { validateWorkspace } from "../workspace/setup.js";
-import { resolveWorkspacePath, VORATIQ_RUNS_DIR, VORATIQ_RUNS_FILE, } from "../workspace/structure.js";
+import { repairWorkspaceStructure, validateWorkspace, } from "../workspace/setup.js";
+import { resolveWorkspacePath, VORATIQ_MESSAGE_DIR, VORATIQ_MESSAGE_FILE, VORATIQ_REDUCTION_DIR, VORATIQ_REDUCTION_FILE, VORATIQ_RUN_DIR, VORATIQ_RUN_FILE, VORATIQ_SPEC_DIR, VORATIQ_SPEC_FILE, VORATIQ_VERIFICATION_DIR, VORATIQ_VERIFICATION_FILE, } from "../workspace/structure.js";
 import { DirtyWorkingTreeError, SandboxDependenciesError, SpecNotFoundError, } from "./errors.js";
 export async function resolveCliContext(options = {}) {
-    const { requireWorkspace = true } = options;
+    const { requireWorkspace = true, workspaceAutoInitMode = "never", restoreShippedVerificationTemplates = true, } = options;
     const root = process.cwd();
     await assertGitRepository(root);
+    const workspaceDir = resolveWorkspacePath(root);
+    const initialWorkspaceExists = await pathExists(workspaceDir);
+    let workspaceAutoInitialized = false;
+    let workspaceAutoRepaired = false;
     if (requireWorkspace) {
+        let workspaceMissing = !initialWorkspaceExists;
+        if (workspaceAutoInitMode === "when-missing" && workspaceMissing) {
+            await executeInitCommand({
+                root,
+                preset: "pro",
+                presetProvided: false,
+                assumeYes: true,
+                interactive: false,
+            });
+            workspaceAutoInitialized = true;
+            workspaceMissing = false;
+        }
+        if (!workspaceMissing) {
+            const repairResult = await repairWorkspaceStructure(root, {
+                restoreShippedVerificationTemplates,
+            });
+            workspaceAutoRepaired = repairResult.repaired;
+        }
         await validateWorkspace(root);
     }
-    const workspaceDir = resolveWorkspacePath(root);
     const workspacePaths = {
         root,
         workspaceDir,
-        runsDir: resolveWorkspacePath(root, VORATIQ_RUNS_DIR),
-        runsFile: resolveWorkspacePath(root, VORATIQ_RUNS_FILE),
+        runsDir: resolveWorkspacePath(root, VORATIQ_RUN_DIR),
+        runsFile: resolveWorkspacePath(root, VORATIQ_RUN_FILE),
+        reductionsDir: resolveWorkspacePath(root, VORATIQ_REDUCTION_DIR),
+        reductionsFile: resolveWorkspacePath(root, VORATIQ_REDUCTION_FILE),
+        messagesDir: resolveWorkspacePath(root, VORATIQ_MESSAGE_DIR),
+        messagesFile: resolveWorkspacePath(root, VORATIQ_MESSAGE_FILE),
+        specsDir: resolveWorkspacePath(root, VORATIQ_SPEC_DIR),
+        specsFile: resolveWorkspacePath(root, VORATIQ_SPEC_FILE),
+        verificationsDir: resolveWorkspacePath(root, VORATIQ_VERIFICATION_DIR),
+        verificationsFile: resolveWorkspacePath(root, VORATIQ_VERIFICATION_FILE),
+    };
+    return {
+        root,
+        workspacePaths,
+        workspaceAutoInitialized,
+        workspaceAutoRepaired,
     };
-    return { root, workspacePaths };
 }
 export async function ensureSpecPath(specPath, root) {
     const absolutePath = isAbsolute(specPath)

package/dist/render/interactions/confirmation.js

@@ -20,7 +20,7 @@ export function createConfirmationInteractor(options = {}) {
                     process.stdout.write(`${line}\n`);
                 }
             }
-            const suffix = defaultValue ? "(Y/n)" : "(y/N)";
+            const suffix = defaultValue ? "[Y/n]" : "[y/N]";
             for (;;) {
                 const response = await readlineInterface.question(`${message} ${suffix}: `);
                 const normalized = response.trim().toLowerCase();
@@ -50,7 +50,9 @@ export function createConfirmationInteractor(options = {}) {
                 }
             }
             const suffix = defaultValue && defaultValue.length > 0 ? ` [${defaultValue}]` : "";
-            const response = await readlineInterface.question(`${message}${suffix}: `);
+            const isInlinePrompt = message.trim() === ">";
+            const promptLabel = isInlinePrompt ? "> " : `${message}${suffix}: `;
+            const response = await readlineInterface.question(promptLabel);
             if (response.trim().length === 0) {
                 return defaultValue ?? "";
             }

package/dist/render/transcripts/apply.js

@@ -1,6 +1,6 @@
 import { colorize } from "../../utils/colors.js";
 import { formatRunWorkspaceRelative } from "../../workspace/layout.js";
-import { buildAgentArtifactPaths, buildAgentEvalViews, getAgentDirectoryPath, getAgentManifestPath, } from "../../workspace/structure.js";
+import { buildAgentArtifactPaths, getAgentDirectoryPath, getAgentManifestPath, } from "../../workspace/structure.js";
 import { formatRunTimestamp } from "../utils/records.js";
 import { renderTranscriptWithMetadata } from "./shared.js";
 export function renderApplyTranscript(result) {
@@ -22,31 +22,30 @@ export function renderApplyTranscript(result) {
         baseDirectory: getAgentDirectoryPath(result.runId, agent.agentId),
         runtimeManifestPath: getAgentManifestPath(result.runId, agent.agentId),
         assets,
-        evals: buildAgentEvalViews({
-            runId: result.runId,
-            agentId: agent.agentId,
-            evals: agent.evals,
-        }),
     };
     const warnings = result.ignoredBaseMismatch
         ? [
             `${colorize("Warning:", "yellow")} Applied despite base mismatch (\`--ignore-base-mismatch\`).`,
         ]
         : undefined;
+    const applyMessage = result.appliedCommitSha
+        ? `Diff applied to working tree (commit: ${result.appliedCommitSha}).`
+        : "Diff applied to working tree.";
+    const afterAgentsLines = [colorize(applyMessage, "green")];
     return renderTranscriptWithMetadata({
         metadata: {
             runId: result.runId,
             status: result.status,
-            specPath: result.specPath,
             workspacePath: formatRunWorkspaceRelative(result.runId),
             createdAt: formatRunTimestamp(result.createdAt),
-            baseRevisionSha: result.baseRevisionSha,
         },
         agents: [agentDisplay],
         warnings,
-        afterAgents: [[colorize("Diff applied to working tree.", "green")]],
+        afterAgents: [afterAgentsLines],
         hint: {
-            message: "Review changes (e.g., `git status`) and run tests before committing.",
+            message: result.appliedCommitSha
+                ? "Review the commit and run tests."
+                : "Review changes and run tests.",
         },
     });
 }

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

@@ -0,0 +1,27 @@
+import type { AutoTerminalStatus } from "../../domain/run/model/types.js";
+import type { RunStatus } from "../../status/index.js";
+export type AutoPhaseStatus = "succeeded" | "failed" | "skipped";
+export interface AutoPhaseSummary {
+    status: AutoPhaseStatus;
+    durationMs?: number;
+    detail?: string;
+}
+export interface AutoSummaryInput {
+    status: AutoTerminalStatus;
+    totalDurationMs: number;
+    spec: AutoPhaseSummary & {
+        specPath?: string;
+    };
+    run: AutoPhaseSummary & {
+        runId?: string;
+        runStatus?: RunStatus;
+        createdAt?: string;
+        specPath?: string;
+        baseRevisionSha?: string;
+    };
+    verify: AutoPhaseSummary;
+    apply?: AutoPhaseSummary & {
+        agentId?: string;
+    };
+}
+export declare function renderAutoSummaryTranscript(input: AutoSummaryInput): string;

package/dist/render/transcripts/auto.js

@@ -0,0 +1,21 @@
+import { getRunStatusStyle } from "../../status/colors.js";
+import { colorize } from "../../utils/colors.js";
+import { formatDurationLabel } from "../utils/duration.js";
+import { renderTranscript } from "../utils/transcript.js";
+export function renderAutoSummaryTranscript(input) {
+    const totalDuration = formatDurationLabel(input.totalDurationMs) ?? "—";
+    const statusLabel = input.status === "action_required"
+        ? "ACTION_REQUIRED"
+        : input.status === "succeeded"
+            ? "SUCCEEDED"
+            : "FAILED";
+    const statusStyle = input.status === "action_required"
+        ? { cli: "yellow" }
+        : getRunStatusStyle((input.status === "succeeded"
+            ? "succeeded"
+            : "failed"));
+    const lines = [
+        `Auto ${colorize(statusLabel, statusStyle.cli)} (${totalDuration})`,
+    ];
+    return renderTranscript({ sections: [lines] });
+}

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

@@ -1,18 +1,7 @@
 import type { InitCommandResult } from "../../commands/init/types.js";
-import type { EvalSlug } from "../../configs/evals/types.js";
-export declare function buildInitializationPrompt(): string;
-interface AgentPromptRenderOptions {
-    agentId: string;
-    binaryPath?: string;
-    detected: boolean;
-    firstPrompt: boolean;
+export declare function renderPresetPromptPreface(firstPrompt: boolean): string[];
+interface RenderInitTranscriptOptions {
+    includeConfigurationHeading?: boolean;
 }
-export declare function renderAgentPromptPreface({ agentId, binaryPath, detected, firstPrompt, }: AgentPromptRenderOptions): string[];
-interface EvalCommandPromptRenderOptions {
-    commandName: EvalSlug;
-    commandText: string;
-    firstPrompt: boolean;
-}
-export declare function renderEvalCommandPreface({ commandName, commandText, firstPrompt, }: EvalCommandPromptRenderOptions): string[];
-export declare function renderInitTranscript({ agentSummary, environmentSummary, evalSummary, sandboxSummary, }: InitCommandResult): string;
+export declare function renderInitTranscript({ preset, agentSummary, orchestrationSummary, environmentSummary, sandboxSummary, }: InitCommandResult, options?: RenderInitTranscriptOptions): string;
 export {};

package/dist/render/transcripts/init.js

@@ -1,84 +1,83 @@
+import { getAgentDefaultsForPreset } from "../../configs/agents/defaults.js";
 import { colorize } from "../../utils/colors.js";
-import { renderTranscript } from "../utils/transcript.js";
-export function buildInitializationPrompt() {
-    return "Initializing Voratiq…";
-}
-export function renderAgentPromptPreface({ agentId, binaryPath, detected, firstPrompt, }) {
-    const lines = [];
-    if (firstPrompt) {
-        lines.push("");
-        lines.push("Configuring agents…");
-        lines.push("");
-    }
-    if (detected && binaryPath) {
-        lines.push(`\`${agentId}\` binary detected: \`${binaryPath}\``);
-    }
-    else {
-        lines.push(`\`${agentId}\` binary not detected. Keeping disabled.`);
-    }
-    return lines;
-}
-export function renderEvalCommandPreface({ commandName, commandText, firstPrompt, }) {
-    const lines = [];
-    if (firstPrompt) {
-        lines.push("");
-        lines.push("Configuring evals…");
-        lines.push("");
-    }
-    lines.push(`\`${commandName}\` command detected: \`${commandText}\``);
-    return lines;
-}
-export function renderInitTranscript({ agentSummary, environmentSummary, evalSummary, sandboxSummary, }) {
-    const sections = [];
-    sections.push(buildAgentsSection(agentSummary));
-    sections.push(buildEnvironmentSection(environmentSummary));
-    sections.push(buildEvalsSection(evalSummary));
-    sections.push(buildSandboxSection(sandboxSummary));
-    sections.push([buildWorkspaceInitializedSection()]);
-    return renderTranscript({
+import { formatWorkspacePath, VORATIQ_VERIFICATION_CONFIG_FILE, } from "../../workspace/structure.js";
+import { renderTable } from "../utils/table.js";
+import { renderBlocks, renderTranscript } from "../utils/transcript.js";
+import { wrapWords } from "../utils/wrap.js";
+const INIT_NOTE_MAX_WIDTH = 79;
+export function renderPresetPromptPreface(firstPrompt) {
+    const sections = [
+        [
+            "Which workspace preset would you like?",
+            "  [1] Pro (flagship)",
+            "  [2] Lite (faster/cheaper)",
+            "  [3] Manual (configure yourself)",
+        ],
+    ];
+    return renderBlocks({
         sections,
-        hint: {
-            message: "To begin a run:\n  voratiq run --spec <path>",
-        },
+        leadingBlankLine: firstPrompt,
     });
 }
-function buildAgentsSection(summary) {
-    const lines = [];
-    if (summary.zeroDetections && summary.enabledAgents.length === 0) {
-        lines.push("No agents configured, unable to find agent binaries.");
-        lines.push(`To modify agent setup manually, edit \`${summary.configPath}\`.`);
-        return lines;
+export function renderInitTranscript({ preset, agentSummary, orchestrationSummary, environmentSummary, sandboxSummary, }, options = {}) {
+    const { includeConfigurationHeading = true } = options;
+    const sections = [];
+    if (includeConfigurationHeading) {
+        sections.push(["Configuring workspace…"]);
     }
-    lines.push(`Agents configured (${formatEnabled(summary.enabledAgents)}).`);
-    lines.push(`To modify, edit \`${summary.configPath}\`.`);
-    return lines;
-}
-function buildEnvironmentSection(summary) {
-    const lines = [];
-    const details = summary.detectedEntries.length > 0
-        ? summary.detectedEntries.join(", ")
-        : "none";
-    lines.push(`Environment configured (${details}).`);
-    lines.push(`To modify, edit \`${summary.configPath}\`.`);
-    return lines;
-}
-function buildEvalsSection(summary) {
-    const lines = [];
-    if (summary.configuredEvals.length === 0) {
-        lines.push("No evals configured, unable to detect project tooling yet.");
-        lines.push(`To modify eval setup manually, edit \`${summary.configPath}\`.`);
-        return lines;
+    sections.push(buildConfigurationSummaryTable({
+        orchestrationPath: orchestrationSummary.configPath,
+        agentsPath: agentSummary.configPath,
+        verificationPath: formatWorkspacePath(VORATIQ_VERIFICATION_CONFIG_FILE),
+        environmentPath: environmentSummary.configPath,
+        sandboxPath: sandboxSummary.configPath,
+    }));
+    const conditionalNote = resolveConditionalInitNote({
+        preset,
+        agentSummary,
+    });
+    if (conditionalNote) {
+        sections.push(wrapWords(conditionalNote, INIT_NOTE_MAX_WIDTH).map((line) => colorize(line, "yellow")));
     }
-    lines.push(`Evals configured (${formatEnabled(summary.configuredEvals)}).`);
-    lines.push(`To modify, edit \`${summary.configPath}\`.`);
-    return lines;
+    sections.push([
+        "Configuration docs:",
+        "  https://github.com/voratiq/voratiq/tree/main/docs/configs",
+    ]);
+    sections.push([buildWorkspaceInitializedSection()]);
+    sections.push(["Run end-to-end:", '  voratiq auto --description "<task>"']);
+    return renderTranscript({ sections });
 }
-function buildSandboxSection(summary) {
-    return ["Sandbox configured.", `To modify, edit \`${summary.configPath}\`.`];
+function buildConfigurationSummaryTable(paths) {
+    return renderTable({
+        columns: [
+            { header: "CONFIGURATION", accessor: (row) => row.configuration },
+            { header: "FILE", accessor: (row) => row.path },
+        ],
+        rows: [
+            { configuration: "agents", path: paths.agentsPath },
+            { configuration: "orchestration", path: paths.orchestrationPath },
+            { configuration: "verification", path: paths.verificationPath },
+            { configuration: "environment", path: paths.environmentPath },
+            { configuration: "sandbox", path: paths.sandboxPath },
+        ],
+    });
 }
 function buildWorkspaceInitializedSection() {
     return colorize("Voratiq initialized.", "green");
 }
-function formatEnabled(values) {
-    return values.length > 0 ? values.join(", ") : "none";
+function resolveConditionalInitNote({ preset, agentSummary, }) {
+    if (agentSummary.zeroDetections) {
+        return "No agent CLIs detected on PATH. Install providers, then update `agents.yaml`.";
+    }
+    if (preset === "manual") {
+        return "Manual preset leaves stages empty. Add agents to `orchestration.yaml`.";
+    }
+    const presetProviders = new Set(getAgentDefaultsForPreset(preset).map((agentDefault) => agentDefault.provider));
+    const detectedProviders = new Set(agentSummary.detectedProviders.map((summary) => summary.provider));
+    for (const presetProvider of presetProviders) {
+        if (!detectedProviders.has(presetProvider)) {
+            return "Some providers not found on PATH. Only detected providers were configured. Install missing ones, then update `agents.yaml`.";
+        }
+    }
+    return undefined;
 }

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

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

package/dist/render/transcripts/list.js

@@ -1,44 +1,150 @@
 import { formatRunTimestamp } from "../utils/records.js";
 import { renderTable } from "../utils/table.js";
 import { renderTranscript } from "../utils/transcript.js";
+const DASH = "—";
+const SPEC_DESCRIPTION_PREVIEW_LENGTH = 32;
+const MESSAGE_PROMPT_PREVIEW_LENGTH = 32;
 export function renderRunList(records) {
     const rows = records.map((record) => ({
         run: record.runId,
-        status: record.status.toUpperCase(),
         spec: record.spec.path,
+        status: record.status.toUpperCase(),
         created: formatRunTimestamp(record.createdAt),
     }));
     const columns = [
         { header: "RUN", accessor: (row) => row.run },
+        { header: "SPEC", accessor: (row) => row.spec },
         {
             header: "STATUS",
             accessor: (row) => row.status,
         },
-        { header: "SPEC", accessor: (row) => row.spec },
         {
             header: "CREATED",
             accessor: (row) => row.created,
         },
     ];
-    const lines = renderTable({
-        columns,
-        rows,
-    });
-    return lines.join("\n");
+    return renderTable({ columns, rows }).join("\n");
 }
 export function renderListTranscript(records) {
     if (records.length === 0) {
         return "";
     }
     const tableOutput = renderRunList(records);
+    return renderListTableTranscript(tableOutput);
+}
+export function renderSpecList(records) {
+    return renderTable({
+        columns: [
+            {
+                header: "SPEC",
+                accessor: (record) => record.sessionId,
+            },
+            {
+                header: "DESCRIPTION",
+                accessor: (record) => truncatePreview(record.description, SPEC_DESCRIPTION_PREVIEW_LENGTH),
+            },
+            {
+                header: "STATUS",
+                accessor: (record) => record.status.toUpperCase(),
+            },
+            {
+                header: "CREATED",
+                accessor: (record) => formatRunTimestamp(record.createdAt),
+            },
+        ],
+        rows: records,
+    }).join("\n");
+}
+export function renderReduceList(records) {
+    return renderTable({
+        columns: [
+            {
+                header: "REDUCE",
+                accessor: (record) => record.sessionId,
+            },
+            {
+                header: "TARGET",
+                accessor: (record) => `${record.target.type}:${record.target.id}`,
+            },
+            {
+                header: "STATUS",
+                accessor: (record) => record.status.toUpperCase(),
+            },
+            {
+                header: "CREATED",
+                accessor: (record) => formatRunTimestamp(record.createdAt),
+            },
+        ],
+        rows: records,
+    }).join("\n");
+}
+export function renderMessageList(records) {
+    return renderTable({
+        columns: [
+            {
+                header: "MESSAGE",
+                accessor: (record) => record.sessionId,
+            },
+            {
+                header: "PROMPT",
+                accessor: (record) => truncatePreview(record.prompt, MESSAGE_PROMPT_PREVIEW_LENGTH),
+            },
+            {
+                header: "STATUS",
+                accessor: (record) => record.status.toUpperCase(),
+            },
+            {
+                header: "CREATED",
+                accessor: (record) => formatRunTimestamp(record.createdAt),
+            },
+        ],
+        rows: records,
+    }).join("\n");
+}
+export function renderVerifyList(records) {
+    return renderTable({
+        columns: [
+            {
+                header: "VERIFY",
+                accessor: (record) => record.sessionId,
+            },
+            {
+                header: "TARGET",
+                accessor: (record) => `${record.target.kind}:${record.target.sessionId}`,
+            },
+            {
+                header: "STATUS",
+                accessor: (record) => record.status.toUpperCase(),
+            },
+            {
+                header: "CREATED",
+                accessor: (record) => formatRunTimestamp(record.createdAt),
+            },
+        ],
+        rows: records,
+    }).join("\n");
+}
+export function renderListTableTranscript(tableOutput) {
+    if (tableOutput.trim().length === 0) {
+        return "";
+    }
     const sections = [];
-    if (tableOutput.trim().length > 0) {
-        sections.push(tableOutput.split("\n"));
+    sections.push(tableOutput.split("\n"));
+    return renderTranscript({ sections });
+}
+function truncatePreview(value, maxLength) {
+    if (!value) {
+        return DASH;
     }
-    return renderTranscript({
-        sections,
-        hint: {
-            message: "To review a run in more detail:\n  voratiq review --run <run-id>",
-        },
-    });
+    const normalized = value.replace(/\s+/g, " ").trim();
+    if (normalized.length === 0) {
+        return DASH;
+    }
+    if (normalized.length <= maxLength) {
+        return normalized;
+    }
+    if (maxLength <= 3) {
+        return normalized.slice(0, maxLength);
+    }
+    return `${normalized.slice(0, maxLength - 3).trimEnd()}...`;
 }

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

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