voratiq 0.1.0-beta.20 → 0.1.0-beta.22

package/README.md

@@ -1,15 +1,11 @@
 # Voratiq
 
-Agent ensembles to design, generate, and select the best code for every task.
+Run workflows, delegate to swarms, and verify outputs before you apply them.
 
-![`voratiq auto --spec .voratiq/spec/categorical-performance-by-taxonomy.md`](https://raw.githubusercontent.com/voratiq/voratiq/main/assets/run-demo.png)
-
-No single model wins every task. Run several, keep the best result. [Here's why that works](https://voratiq.com/blog/selection-rather-than-prediction/).
+Voratiq provides composable operators for structured multi-agent workflows, with durable artifacts and session history that keep each step inspectable as work unfolds.
 
 ## Installation
 
-Install via npm:
-
 ```bash
 npm install -g voratiq
 ```
@@ -23,7 +19,7 @@ npm install -g voratiq
 - macOS: `ripgrep`
 - Linux (Debian/Ubuntu): `bubblewrap`, `socat`, `ripgrep`
 
-See the [sandbox runtime docs](https://github.com/anthropic-experimental/sandbox-runtime/blob/1bafa66a2c3ebc52569fc0c1a868e85e778f66a0/README.md#platform-specific-dependencies) for guidance on the platform-specific dependencies.
+See the [sandbox runtime docs](https://github.com/anthropic-experimental/sandbox-runtime/blob/1bafa66a2c3ebc52569fc0c1a868e85e778f66a0/README.md#platform-specific-dependencies) for platform-specific dependencies.
 
 Windows is not currently supported.
 
@@ -31,40 +27,40 @@ Windows is not currently supported.
 
 ## Quick Start
 
-Get started with a single command:
+From a git repo root, run:
 
 ```bash
 voratiq
 ```
 
-This drops you into an interactive session with an agent of your choice.
-
-That agent gets access to Voratiq tools for orchestration and verification.
+That opens an interactive agent session with access to Voratiq's operators.
 
-Describe what you want built, and the agent can use those tools to:
+From there, the agent can:
 
-- turn your request into a structured execution plan
-- delegate work to a custom-designed swarm or a multi-stage workflow
-- verify outputs and compare alternatives before choosing what to keep
-- track outcomes across runs to learn which agents and workflows work best
+- run multi-step workflows with explicit stages
+- delegate work to swarms of agents
+- verify outputs before applying them
+- use different workflow architectures for different tasks
+- inspect session history and artifacts
 
-You keep the native interactive workflow, with more execution depth and control.
+For more information, see the [getting started](https://github.com/voratiq/voratiq/blob/main/docs/getting-started.md) guide.
 
 ## Documentation
 
 Start here:
 
-- [Tutorial](https://github.com/voratiq/voratiq/blob/main/docs/tutorial.md) - End-to-end walkthrough
+- [Getting Started](https://github.com/voratiq/voratiq/blob/main/docs/getting-started.md) - Which workflow to use and how to run it
+- [How It Works](https://github.com/voratiq/voratiq/blob/main/docs/how-it-works.md) - Operators, verification, and artifacts
 - [CLI Reference](https://github.com/voratiq/voratiq/blob/main/docs/cli-reference.md) - Commands and options
-- [Core Concepts](https://github.com/voratiq/voratiq/blob/main/docs/core-concepts.md) - Workflow model and design rationale
+- [Troubleshooting](https://github.com/voratiq/voratiq/blob/main/docs/troubleshooting.md) - Common setup and runtime issues
 
 Configuration:
 
 - [Agents](https://github.com/voratiq/voratiq/blob/main/docs/configs/agents.md) - Agent catalog and invocation details
-- [Orchestration](https://github.com/voratiq/voratiq/blob/main/docs/configs/orchestration.md) - Which agents run at each stage
-- [Verification](https://github.com/voratiq/voratiq/blob/main/docs/configs/verification.md) - How agent outputs are checked and scored before selection
-- [Environment](https://github.com/voratiq/voratiq/blob/main/docs/configs/environment.md) - Runtime dependencies for agents
+- [Environment](https://github.com/voratiq/voratiq/blob/main/docs/configs/environment.md) - Runtime dependencies for agent execution
 - [Sandbox](https://github.com/voratiq/voratiq/blob/main/docs/configs/sandbox.md) - Network and filesystem restrictions
+- [Orchestration](https://github.com/voratiq/voratiq/blob/main/docs/configs/orchestration.md) - Which agents participate at each workflow stage
+- [Verification](https://github.com/voratiq/voratiq/blob/main/docs/configs/verification.md) - How verification is configured across stages
 
 ## License
 

package/dist/agents/launch/chat.d.ts

@@ -1,4 +1,4 @@
-import { type ProviderTranscriptBaseline } from "../../workspace/chat/artifacts.js";
+import { type ProviderTranscriptBaseline, type ProviderTranscriptSelectionHint } from "../../workspace/chat/artifacts.js";
 import type { ChatArtifactFormat } from "../../workspace/chat/types.js";
 export interface LaunchArtifactCaptureResult {
     readonly captured: boolean;
@@ -10,11 +10,13 @@ export interface LaunchArtifactCaptureResult {
 export interface LaunchArtifactCaptureContext {
     readonly searchEnv?: NodeJS.ProcessEnv;
     readonly baseline?: ProviderTranscriptBaseline;
+    readonly selectionHint?: ProviderTranscriptSelectionHint;
 }
 export declare function prepareProviderArtifactCaptureContext(options: {
     providerId: string | undefined;
     sessionRoot: string;
     searchEnv?: NodeJS.ProcessEnv;
+    selectionHint?: ProviderTranscriptSelectionHint;
 }): Promise<LaunchArtifactCaptureContext | undefined>;
 export declare function collectProviderArtifacts(options: {
     providerId: string | undefined;

package/dist/agents/launch/chat.js

@@ -11,6 +11,7 @@ export async function prepareProviderArtifactCaptureContext(options) {
             agentRoot: options.sessionRoot,
             searchEnv: options.searchEnv,
         }),
+        selectionHint: options.selectionHint,
     };
 }
 export async function collectProviderArtifacts(options) {
@@ -23,6 +24,7 @@ export async function collectProviderArtifacts(options) {
         agentRoot: options.sessionRoot,
         searchEnv: options.captureContext?.searchEnv,
         baseline: options.captureContext?.baseline,
+        selectionHint: options.captureContext?.selectionHint,
     });
     const format = result.format;
     if ((result.status === "captured" || result.status === "already-exists") &&

package/dist/agents/runtime/policy.d.ts

@@ -1,6 +1,6 @@
 import type { SandboxFilesystemConfig, SandboxNetworkConfig } from "../../configs/sandbox/types.js";
 import type { SandboxPolicyOverrides } from "./types.js";
-export type SandboxStageId = "run" | "spec" | "verify" | "reduce";
+export type SandboxStageId = "spec" | "run" | "reduce" | "verify" | "message";
 export interface BuildSandboxPolicyInput {
     stageId: SandboxStageId;
     root: string;

package/dist/bin.js

@@ -65,6 +65,13 @@ async function handleSignal(signal) {
     process.exit(exitCode);
 }
 async function flushPendingHistory() {
+    try {
+        const { flushAllSpecRecordBuffers } = await import("./domain/spec/persistence/adapter.js");
+        await flushAllSpecRecordBuffers();
+    }
+    catch (error) {
+        console.warn(`[voratiq] Failed to flush spec history buffers: ${error.message}`);
+    }
     try {
         const { flushAllRunRecordBuffers } = await import("./domain/run/persistence/adapter.js");
         await flushAllRunRecordBuffers();
@@ -73,32 +80,32 @@ async function flushPendingHistory() {
         console.warn(`[voratiq] Failed to flush run history buffers: ${error.message}`);
     }
     try {
-        const { flushAllVerificationRecordBuffers } = await import("./domain/verify/persistence/adapter.js");
-        await flushAllVerificationRecordBuffers();
+        const { flushAllReductionRecordBuffers } = await import("./domain/reduce/persistence/adapter.js");
+        await flushAllReductionRecordBuffers();
     }
     catch (error) {
-        console.warn(`[voratiq] Failed to flush verification history buffers: ${error.message}`);
+        console.warn(`[voratiq] Failed to flush reduction history buffers: ${error.message}`);
     }
     try {
-        const { flushAllInteractiveSessionBuffers } = await import("./domain/interactive/persistence/adapter.js");
-        await flushAllInteractiveSessionBuffers();
+        const { flushAllVerificationRecordBuffers } = await import("./domain/verify/persistence/adapter.js");
+        await flushAllVerificationRecordBuffers();
     }
     catch (error) {
-        console.warn(`[voratiq] Failed to flush interactive history buffers: ${error.message}`);
+        console.warn(`[voratiq] Failed to flush verification history buffers: ${error.message}`);
     }
     try {
-        const { flushAllSpecRecordBuffers } = await import("./domain/spec/persistence/adapter.js");
-        await flushAllSpecRecordBuffers();
+        const { flushAllMessageRecordBuffers } = await import("./domain/message/persistence/adapter.js");
+        await flushAllMessageRecordBuffers();
     }
     catch (error) {
-        console.warn(`[voratiq] Failed to flush spec history buffers: ${error.message}`);
+        console.warn(`[voratiq] Failed to flush message history buffers: ${error.message}`);
     }
     try {
-        const { flushAllReductionRecordBuffers } = await import("./domain/reduce/persistence/adapter.js");
-        await flushAllReductionRecordBuffers();
+        const { flushAllInteractiveSessionBuffers } = await import("./domain/interactive/persistence/adapter.js");
+        await flushAllInteractiveSessionBuffers();
     }
     catch (error) {
-        console.warn(`[voratiq] Failed to flush reduction history buffers: ${error.message}`);
+        console.warn(`[voratiq] Failed to flush interactive history buffers: ${error.message}`);
     }
 }
 async function terminateActiveRunSafe(status, context) {
@@ -140,16 +147,50 @@ async function terminateActiveInteractiveSafe(status, context) {
         return normalizedError;
     }
 }
+async function terminateActiveMessageSafe(status, context) {
+    try {
+        const { terminateActiveMessage } = await import("./commands/message/lifecycle.js");
+        await terminateActiveMessage(status);
+        return null;
+    }
+    catch (error) {
+        const { toErrorMessage } = await import("./utils/errors.js");
+        const normalizedError = error instanceof Error ? error : new Error(toErrorMessage(error));
+        console.error(`[voratiq] Failed to teardown message after ${context}: ${toErrorMessage(error)}`);
+        return normalizedError;
+    }
+}
 async function terminateActiveSessionsSafe(status, context) {
     const runError = await terminateActiveRunSafe(status, context);
     const verificationError = await terminateActiveVerificationSafe(status, context);
     const interactiveError = await terminateActiveInteractiveSafe(status, context);
-    const errors = [runError, verificationError, interactiveError].filter((error) => error instanceof Error);
+    const messageError = await terminateActiveMessageSafe(status, context);
+    const errors = [
+        runError,
+        verificationError,
+        interactiveError,
+        messageError,
+    ].filter((error) => error instanceof Error);
     if (errors.length > 1) {
         return new AggregateError(errors, `Failed to teardown active sessions after ${context}`);
     }
     return errors[0] ?? null;
 }
+function renderRootLauncherGitGuidance(options) {
+    const lines = [];
+    if (options.reason === "not_repository_root") {
+        lines.push("Bare `voratiq` launches an interactive session from a repository root.", "", `Current directory: ${options.cwd}`);
+        if (options.repositoryRoot) {
+            lines.push(`Repository root: ${options.repositoryRoot}`);
+        }
+        lines.push("", "Next step:", options.repositoryRoot
+            ? `  cd ${options.repositoryRoot} && voratiq`
+            : "  Switch to the repository root and rerun `voratiq`.");
+        return lines.join("\n");
+    }
+    lines.push("Bare `voratiq` launches an interactive session from a git repository root.", "", `Current directory: ${options.cwd}`, "", "Next steps:", "  git init", "  voratiq", "", "Or switch to an existing repository root and rerun `voratiq`.");
+    return lines.join("\n");
+}
 export async function runCli(argv = process.argv) {
     installProcessGuards();
     const { Command, CommanderError } = await import("commander");
@@ -162,7 +203,7 @@ export async function runCli(argv = process.argv) {
     const localVersion = (await import("./utils/version.js")).getVoratiqVersion();
     program
         .name("voratiq")
-        .description("Agent ensembles to design, generate, and select the best code for every task.")
+        .description("Run workflows, delegate to swarms, and verify outputs before you apply them.")
         .enablePositionalOptions()
         .version(localVersion, "-v, --version", "print the Voratiq version")
         .exitOverride()
@@ -228,7 +269,13 @@ export async function runCli(argv = process.argv) {
                     (error.reason === "no_repository" ||
                         error.reason === "not_repository_root")) {
                     const { writeCommandOutput } = await import("./cli/output.js");
-                    writeCommandOutput({ body: program.helpInformation() });
+                    writeCommandOutput({
+                        body: renderRootLauncherGitGuidance({
+                            cwd: process.cwd(),
+                            reason: error.reason,
+                            repositoryRoot: error.repositoryRoot,
+                        }),
+                    });
                     return;
                 }
                 const { toCliError } = await import("./cli/errors.js");
@@ -304,15 +351,16 @@ async function registerCommands(program, argv) {
     const wantsHelp = argv.includes("--help") || argv.includes("-h");
     const wantsVersion = argv.includes("--version") || argv.includes("-v");
     const knownCommandNames = new Set([
-        "auto",
-        "init",
         "spec",
         "run",
-        "verify",
         "reduce",
+        "verify",
+        "message",
+        "auto",
         "apply",
         "list",
         "prune",
+        "doctor",
         "mcp",
     ]);
     const loadAll = commandName === undefined ||
@@ -322,25 +370,20 @@ async function registerCommands(program, argv) {
         return;
     }
     if (loadAll) {
-        program.addCommand((await import("./cli/auto.js")).createAutoCommand());
-        program.addCommand((await import("./cli/init.js")).createInitCommand());
         program.addCommand((await import("./cli/spec.js")).createSpecCommand());
         program.addCommand((await import("./cli/run.js")).createRunCommand());
         program.addCommand((await import("./cli/reduce.js")).createReduceCommand());
         program.addCommand((await import("./cli/verify.js")).createVerifyCommand());
+        program.addCommand((await import("./cli/message.js")).createMessageCommand());
+        program.addCommand((await import("./cli/auto.js")).createAutoCommand());
         program.addCommand((await import("./cli/apply.js")).createApplyCommand());
         program.addCommand((await import("./cli/list.js")).createListCommand());
         program.addCommand((await import("./cli/prune.js")).createPruneCommand());
+        program.addCommand((await import("./cli/doctor.js")).createDoctorCommand());
         program.addCommand((await import("./cli/mcp.js")).createMcpCommand());
         return;
     }
     switch (commandName) {
-        case "init":
-            program.addCommand((await import("./cli/init.js")).createInitCommand());
-            break;
-        case "list":
-            program.addCommand((await import("./cli/list.js")).createListCommand());
-            break;
         case "spec":
             program.addCommand((await import("./cli/spec.js")).createSpecCommand());
             break;
@@ -353,15 +396,24 @@ async function registerCommands(program, argv) {
         case "verify":
             program.addCommand((await import("./cli/verify.js")).createVerifyCommand());
             break;
+        case "message":
+            program.addCommand((await import("./cli/message.js")).createMessageCommand());
+            break;
         case "auto":
             program.addCommand((await import("./cli/auto.js")).createAutoCommand());
             break;
         case "apply":
             program.addCommand((await import("./cli/apply.js")).createApplyCommand());
             break;
+        case "list":
+            program.addCommand((await import("./cli/list.js")).createListCommand());
+            break;
         case "prune":
             program.addCommand((await import("./cli/prune.js")).createPruneCommand());
             break;
+        case "doctor":
+            program.addCommand((await import("./cli/doctor.js")).createDoctorCommand());
+            break;
         case "mcp":
             program.addCommand((await import("./cli/mcp.js")).createMcpCommand());
             break;

package/dist/cli/auto.js

@@ -157,6 +157,7 @@ export async function runAutoCommand(options, runtime = {}) {
                 selectedSpecPath: result.selectedSpecPath,
                 selection: result.selection?.decision,
                 selectionWarnings: result.selection?.warnings,
+                warningMessage: result.warningMessage,
             })),
             runApplyStage: async (input) => runApplyCommand({
                 runId: input.runId,

package/dist/cli/contract.d.ts

@@ -1,25 +1,28 @@
 import { type Command } from "commander";
 import { z } from "zod";
 import { type ListMode, type ListOperator } from "../contracts/list.js";
-export declare const externalExecutionOperators: readonly ["spec", "run", "reduce", "verify", "apply", "prune"];
-export declare const externalInspectionOperators: readonly ["spec", "run", "reduce", "verify"];
+export declare const externalExecutionOperators: readonly ["spec", "run", "reduce", "verify", "message", "apply", "prune"];
+export declare const externalInspectionOperators: readonly ["spec", "run", "reduce", "verify", "message", "interactive"];
 export declare const externalInspectionModes: readonly ["table", "detail"];
 export type ExternalExecutionOperator = (typeof externalExecutionOperators)[number];
 export type ExternalInspectionOperator = ListOperator;
 export type ExternalInspectionMode = ListMode;
 export declare const externalExecutionOperatorSchema: z.ZodEnum<{
+    message: "message";
+    spec: "spec";
     reduce: "reduce";
     apply: "apply";
-    spec: "spec";
     run: "run";
     verify: "verify";
     prune: "prune";
 }>;
 export declare const externalInspectionOperatorSchema: z.ZodEnum<{
-    reduce: "reduce";
+    message: "message";
     spec: "spec";
+    reduce: "reduce";
     run: "run";
     verify: "verify";
+    interactive: "interactive";
 }>;
 export declare const externalInspectionModeSchema: z.ZodEnum<{
     detail: "detail";
@@ -44,8 +47,9 @@ export declare const externalRunExecutionInputSchema: z.ZodObject<{
 export declare const externalReduceExecutionInputSchema: z.ZodObject<{
     target: z.ZodObject<{
         type: z.ZodEnum<{
-            reduce: "reduce";
+            message: "message";
             spec: "spec";
+            reduce: "reduce";
             run: "run";
             verify: "verify";
         }>;
@@ -56,11 +60,19 @@ export declare const externalReduceExecutionInputSchema: z.ZodObject<{
     maxParallel: z.ZodOptional<z.ZodNumber>;
     extraContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
+export declare const externalMessageExecutionInputSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    agentIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    profile: z.ZodOptional<z.ZodString>;
+    maxParallel: z.ZodOptional<z.ZodNumber>;
+    extraContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
 export declare const externalVerifyExecutionInputSchema: z.ZodObject<{
     target: z.ZodObject<{
         kind: z.ZodEnum<{
-            reduce: "reduce";
+            message: "message";
             spec: "spec";
+            reduce: "reduce";
             run: "run";
         }>;
         sessionId: z.ZodString;
@@ -88,10 +100,12 @@ export declare const externalPruneExecutionInputSchema: z.ZodDiscriminatedUnion<
 }, z.core.$strict>], "scope">;
 export declare const externalListTableInputSchema: z.ZodObject<{
     operator: z.ZodEnum<{
-        reduce: "reduce";
+        message: "message";
         spec: "spec";
+        reduce: "reduce";
         run: "run";
         verify: "verify";
+        interactive: "interactive";
     }>;
     verbose: z.ZodOptional<z.ZodBoolean>;
     limit: z.ZodOptional<z.ZodNumber>;
@@ -99,10 +113,12 @@ export declare const externalListTableInputSchema: z.ZodObject<{
 }, z.core.$strict>;
 export declare const externalListDetailInputSchema: z.ZodObject<{
     operator: z.ZodEnum<{
-        reduce: "reduce";
+        message: "message";
         spec: "spec";
+        reduce: "reduce";
         run: "run";
         verify: "verify";
+        interactive: "interactive";
     }>;
     verbose: z.ZodOptional<z.ZodBoolean>;
     limit: z.ZodOptional<z.ZodNumber>;
@@ -111,20 +127,24 @@ export declare const externalListDetailInputSchema: z.ZodObject<{
 }, z.core.$strict>;
 export declare const externalListInspectionInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     operator: z.ZodEnum<{
-        reduce: "reduce";
+        message: "message";
         spec: "spec";
+        reduce: "reduce";
         run: "run";
         verify: "verify";
+        interactive: "interactive";
     }>;
     verbose: z.ZodOptional<z.ZodBoolean>;
     limit: z.ZodOptional<z.ZodNumber>;
     mode: z.ZodLiteral<"table">;
 }, z.core.$strict>, z.ZodObject<{
     operator: z.ZodEnum<{
-        reduce: "reduce";
+        message: "message";
         spec: "spec";
+        reduce: "reduce";
         run: "run";
         verify: "verify";
+        interactive: "interactive";
     }>;
     verbose: z.ZodOptional<z.ZodBoolean>;
     limit: z.ZodOptional<z.ZodNumber>;
@@ -151,8 +171,9 @@ export declare const externalExecutionInputSchemas: {
     readonly reduce: z.ZodObject<{
         target: z.ZodObject<{
             type: z.ZodEnum<{
-                reduce: "reduce";
+                message: "message";
                 spec: "spec";
+                reduce: "reduce";
                 run: "run";
                 verify: "verify";
             }>;
@@ -166,8 +187,9 @@ export declare const externalExecutionInputSchemas: {
     readonly verify: z.ZodObject<{
         target: z.ZodObject<{
             kind: z.ZodEnum<{
-                reduce: "reduce";
+                message: "message";
                 spec: "spec";
+                reduce: "reduce";
                 run: "run";
             }>;
             sessionId: z.ZodString;
@@ -177,6 +199,13 @@ export declare const externalExecutionInputSchemas: {
         maxParallel: z.ZodOptional<z.ZodNumber>;
         extraContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>;
+    readonly message: z.ZodObject<{
+        prompt: z.ZodString;
+        agentIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        profile: z.ZodOptional<z.ZodString>;
+        maxParallel: z.ZodOptional<z.ZodNumber>;
+        extraContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
     readonly apply: z.ZodObject<{
         runId: z.ZodString;
         agentId: z.ZodString;
@@ -198,10 +227,12 @@ export declare const externalInspectionInputSchemas: {
     readonly list: {
         readonly table: z.ZodObject<{
             operator: z.ZodEnum<{
-                reduce: "reduce";
+                message: "message";
                 spec: "spec";
+                reduce: "reduce";
                 run: "run";
                 verify: "verify";
+                interactive: "interactive";
             }>;
             verbose: z.ZodOptional<z.ZodBoolean>;
             limit: z.ZodOptional<z.ZodNumber>;
@@ -209,10 +240,12 @@ export declare const externalInspectionInputSchemas: {
         }, z.core.$strict>;
         readonly detail: z.ZodObject<{
             operator: z.ZodEnum<{
-                reduce: "reduce";
+                message: "message";
                 spec: "spec";
+                reduce: "reduce";
                 run: "run";
                 verify: "verify";
+                interactive: "interactive";
             }>;
             verbose: z.ZodOptional<z.ZodBoolean>;
             limit: z.ZodOptional<z.ZodNumber>;
@@ -221,20 +254,24 @@ export declare const externalInspectionInputSchemas: {
         }, z.core.$strict>;
         readonly union: z.ZodDiscriminatedUnion<[z.ZodObject<{
             operator: z.ZodEnum<{
-                reduce: "reduce";
+                message: "message";
                 spec: "spec";
+                reduce: "reduce";
                 run: "run";
                 verify: "verify";
+                interactive: "interactive";
             }>;
             verbose: z.ZodOptional<z.ZodBoolean>;
             limit: z.ZodOptional<z.ZodNumber>;
             mode: z.ZodLiteral<"table">;
         }, z.core.$strict>, z.ZodObject<{
             operator: z.ZodEnum<{
-                reduce: "reduce";
+                message: "message";
                 spec: "spec";
+                reduce: "reduce";
                 run: "run";
                 verify: "verify";
+                interactive: "interactive";
             }>;
             verbose: z.ZodOptional<z.ZodBoolean>;
             limit: z.ZodOptional<z.ZodNumber>;
@@ -246,13 +283,14 @@ export declare const externalInspectionInputSchemas: {
 export type ExternalSpecExecutionInput = z.infer<typeof externalSpecExecutionInputSchema>;
 export type ExternalRunExecutionInput = z.infer<typeof externalRunExecutionInputSchema>;
 export type ExternalReduceExecutionInput = z.infer<typeof externalReduceExecutionInputSchema>;
+export type ExternalMessageExecutionInput = z.infer<typeof externalMessageExecutionInputSchema>;
 export type ExternalVerifyExecutionInput = z.infer<typeof externalVerifyExecutionInputSchema>;
 export type ExternalApplyExecutionInput = z.infer<typeof externalApplyExecutionInputSchema>;
 export type ExternalPruneExecutionInput = z.infer<typeof externalPruneExecutionInputSchema>;
 export type ExternalListInspectionInput = z.infer<typeof externalListInspectionInputSchema>;
 export declare const externalAdapterContractReference: {
     readonly execution: {
-        readonly operators: readonly ["spec", "run", "reduce", "verify", "apply", "prune"];
+        readonly operators: readonly ["spec", "run", "reduce", "verify", "message", "apply", "prune"];
         readonly envelope: {
             readonly authoritativeType: "OperatorResultEnvelope";
             readonly versioned: true;
@@ -262,12 +300,12 @@ export declare const externalAdapterContractReference: {
     readonly inspection: {
         readonly command: "list";
         readonly jsonOnly: true;
-        readonly operators: readonly ["spec", "run", "reduce", "verify"];
+        readonly operators: readonly ["spec", "run", "reduce", "verify", "message", "interactive"];
         readonly modes: readonly ["table", "detail"];
         readonly authoritativeType: "ListJsonOutput";
         readonly versioned: false;
     };
-    readonly excludedCommands: readonly ["auto", "init"];
+    readonly excludedCommands: readonly ["auto", "doctor"];
     readonly compatibility: {
         readonly additiveChangesAreNonBreaking: true;
         readonly breakingChangesRequireExecutionEnvelopeVersionBump: true;
@@ -291,6 +329,7 @@ export interface PruneCommandSelection {
 export declare function parseSpecExecutionCommandOptions(options: unknown, command: Command): ExternalSpecExecutionInput;
 export declare function parseRunExecutionCommandOptions(options: unknown, command: Command): ExternalRunExecutionInput;
 export declare function parseReduceExecutionCommandOptions(options: unknown, command: Command): ExternalReduceExecutionInput;
+export declare function parseMessageExecutionCommandOptions(options: unknown, command: Command): ExternalMessageExecutionInput;
 export declare function parseVerifyExecutionCommandOptions(options: unknown, command: Command): ExternalVerifyExecutionInput;
 export declare function parseApplyExecutionCommandOptions(options: unknown, command: Command): ExternalApplyExecutionInput;
 export declare function parseExternalPruneExecutionInput(input: unknown): ExternalPruneExecutionInput;