voratiq 0.1.0-beta.21 → 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/bin.js

@@ -176,6 +176,21 @@ async function terminateActiveSessionsSafe(status, 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");
@@ -188,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()
@@ -254,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");
@@ -330,7 +351,6 @@ 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([
-        "init",
         "spec",
         "run",
         "reduce",
@@ -340,6 +360,7 @@ async function registerCommands(program, argv) {
         "apply",
         "list",
         "prune",
+        "doctor",
         "mcp",
     ]);
     const loadAll = commandName === undefined ||
@@ -349,7 +370,6 @@ async function registerCommands(program, argv) {
         return;
     }
     if (loadAll) {
-        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());
@@ -359,13 +379,11 @@ async function registerCommands(program, argv) {
         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 "spec":
             program.addCommand((await import("./cli/spec.js")).createSpecCommand());
             break;
@@ -393,6 +411,9 @@ async function registerCommands(program, argv) {
         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

@@ -2,26 +2,27 @@ 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", "message", "apply", "prune"];
-export declare const externalInspectionOperators: readonly ["spec", "run", "reduce", "verify", "message"];
+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<{
     message: "message";
-    reduce: "reduce";
     spec: "spec";
+    reduce: "reduce";
     run: "run";
     verify: "verify";
+    interactive: "interactive";
 }>;
 export declare const externalInspectionModeSchema: z.ZodEnum<{
     detail: "detail";
@@ -47,8 +48,8 @@ export declare const externalReduceExecutionInputSchema: z.ZodObject<{
     target: z.ZodObject<{
         type: z.ZodEnum<{
             message: "message";
-            reduce: "reduce";
             spec: "spec";
+            reduce: "reduce";
             run: "run";
             verify: "verify";
         }>;
@@ -70,8 +71,8 @@ export declare const externalVerifyExecutionInputSchema: z.ZodObject<{
     target: z.ZodObject<{
         kind: z.ZodEnum<{
             message: "message";
-            reduce: "reduce";
             spec: "spec";
+            reduce: "reduce";
             run: "run";
         }>;
         sessionId: z.ZodString;
@@ -100,10 +101,11 @@ export declare const externalPruneExecutionInputSchema: z.ZodDiscriminatedUnion<
 export declare const externalListTableInputSchema: z.ZodObject<{
     operator: z.ZodEnum<{
         message: "message";
-        reduce: "reduce";
         spec: "spec";
+        reduce: "reduce";
         run: "run";
         verify: "verify";
+        interactive: "interactive";
     }>;
     verbose: z.ZodOptional<z.ZodBoolean>;
     limit: z.ZodOptional<z.ZodNumber>;
@@ -112,10 +114,11 @@ export declare const externalListTableInputSchema: z.ZodObject<{
 export declare const externalListDetailInputSchema: z.ZodObject<{
     operator: z.ZodEnum<{
         message: "message";
-        reduce: "reduce";
         spec: "spec";
+        reduce: "reduce";
         run: "run";
         verify: "verify";
+        interactive: "interactive";
     }>;
     verbose: z.ZodOptional<z.ZodBoolean>;
     limit: z.ZodOptional<z.ZodNumber>;
@@ -125,10 +128,11 @@ export declare const externalListDetailInputSchema: z.ZodObject<{
 export declare const externalListInspectionInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     operator: z.ZodEnum<{
         message: "message";
-        reduce: "reduce";
         spec: "spec";
+        reduce: "reduce";
         run: "run";
         verify: "verify";
+        interactive: "interactive";
     }>;
     verbose: z.ZodOptional<z.ZodBoolean>;
     limit: z.ZodOptional<z.ZodNumber>;
@@ -136,10 +140,11 @@ export declare const externalListInspectionInputSchema: z.ZodDiscriminatedUnion<
 }, z.core.$strict>, z.ZodObject<{
     operator: z.ZodEnum<{
         message: "message";
-        reduce: "reduce";
         spec: "spec";
+        reduce: "reduce";
         run: "run";
         verify: "verify";
+        interactive: "interactive";
     }>;
     verbose: z.ZodOptional<z.ZodBoolean>;
     limit: z.ZodOptional<z.ZodNumber>;
@@ -167,8 +172,8 @@ export declare const externalExecutionInputSchemas: {
         target: z.ZodObject<{
             type: z.ZodEnum<{
                 message: "message";
-                reduce: "reduce";
                 spec: "spec";
+                reduce: "reduce";
                 run: "run";
                 verify: "verify";
             }>;
@@ -183,8 +188,8 @@ export declare const externalExecutionInputSchemas: {
         target: z.ZodObject<{
             kind: z.ZodEnum<{
                 message: "message";
-                reduce: "reduce";
                 spec: "spec";
+                reduce: "reduce";
                 run: "run";
             }>;
             sessionId: z.ZodString;
@@ -223,10 +228,11 @@ export declare const externalInspectionInputSchemas: {
         readonly table: z.ZodObject<{
             operator: z.ZodEnum<{
                 message: "message";
-                reduce: "reduce";
                 spec: "spec";
+                reduce: "reduce";
                 run: "run";
                 verify: "verify";
+                interactive: "interactive";
             }>;
             verbose: z.ZodOptional<z.ZodBoolean>;
             limit: z.ZodOptional<z.ZodNumber>;
@@ -235,10 +241,11 @@ export declare const externalInspectionInputSchemas: {
         readonly detail: z.ZodObject<{
             operator: z.ZodEnum<{
                 message: "message";
-                reduce: "reduce";
                 spec: "spec";
+                reduce: "reduce";
                 run: "run";
                 verify: "verify";
+                interactive: "interactive";
             }>;
             verbose: z.ZodOptional<z.ZodBoolean>;
             limit: z.ZodOptional<z.ZodNumber>;
@@ -248,10 +255,11 @@ export declare const externalInspectionInputSchemas: {
         readonly union: z.ZodDiscriminatedUnion<[z.ZodObject<{
             operator: z.ZodEnum<{
                 message: "message";
-                reduce: "reduce";
                 spec: "spec";
+                reduce: "reduce";
                 run: "run";
                 verify: "verify";
+                interactive: "interactive";
             }>;
             verbose: z.ZodOptional<z.ZodBoolean>;
             limit: z.ZodOptional<z.ZodNumber>;
@@ -259,10 +267,11 @@ export declare const externalInspectionInputSchemas: {
         }, z.core.$strict>, z.ZodObject<{
             operator: z.ZodEnum<{
                 message: "message";
-                reduce: "reduce";
                 spec: "spec";
+                reduce: "reduce";
                 run: "run";
                 verify: "verify";
+                interactive: "interactive";
             }>;
             verbose: z.ZodOptional<z.ZodBoolean>;
             limit: z.ZodOptional<z.ZodNumber>;
@@ -291,12 +300,12 @@ export declare const externalAdapterContractReference: {
     readonly inspection: {
         readonly command: "list";
         readonly jsonOnly: true;
-        readonly operators: readonly ["spec", "run", "reduce", "verify", "message"];
+        readonly operators: readonly ["spec", "run", "reduce", "verify", "message", "interactive"];
         readonly modes: readonly ["table", "detail"];
         readonly authoritativeType: "ListJsonOutput";
         readonly versioned: false;
     };
-    readonly excludedCommands: readonly ["init", "auto"];
+    readonly excludedCommands: readonly ["auto", "doctor"];
     readonly compatibility: {
         readonly additiveChangesAreNonBreaking: true;
         readonly breakingChangesRequireExecutionEnvelopeVersionBump: true;

package/dist/cli/contract.js

@@ -154,7 +154,7 @@ export const externalAdapterContractReference = {
         authoritativeType: "ListJsonOutput",
         versioned: false,
     },
-    excludedCommands: ["init", "auto"],
+    excludedCommands: ["auto", "doctor"],
     compatibility: {
         additiveChangesAreNonBreaking: true,
         breakingChangesRequireExecutionEnvelopeVersionBump: true,
@@ -249,6 +249,7 @@ const listCommandActionOptionsSchema = z
     reduce: z.union([z.literal(true), nonEmptyStringSchema]).optional(),
     verify: z.union([z.literal(true), nonEmptyStringSchema]).optional(),
     message: z.union([z.literal(true), nonEmptyStringSchema]).optional(),
+    interactive: z.union([z.literal(true), nonEmptyStringSchema]).optional(),
     limit: positiveIntegerSchema.optional(),
     verbose: z.boolean().optional(),
     json: z.boolean().optional(),
@@ -365,6 +366,7 @@ export function parseListInspectionCommandOptions(options, command) {
         { key: "reduce", flag: "--reduce", value: "reduce" },
         { key: "verify", flag: "--verify", value: "verify" },
         { key: "message", flag: "--message", value: "message" },
+        { key: "interactive", flag: "--interactive", value: "interactive" },
     ], parsed, command, "operator flag");
     return parseCommandOptions(externalListInspectionInputSchema, {
         operator: selected.value,

package/dist/cli/doctor.d.ts

@@ -0,0 +1,12 @@
+import { Command } from "commander";
+import { type CommandOutputWriter } from "./output.js";
+export interface DoctorCommandOptions {
+    fix?: boolean;
+    writeOutput?: CommandOutputWriter;
+}
+export interface RunDoctorCommandResult {
+    body: string;
+    exitCode: number;
+}
+export declare function runDoctorCommand(options?: DoctorCommandOptions): Promise<RunDoctorCommandResult>;
+export declare function createDoctorCommand(): Command;

package/dist/cli/doctor.js

@@ -0,0 +1,115 @@
+import { Command } from "commander";
+import { CliError } from "../cli/errors.js";
+import { executeDoctorDiagnosis, executeDoctorFix, resolveDoctorFixMode, } from "../commands/doctor/command.js";
+import { PREFLIGHT_HINT } from "../competition/shared/preflight.js";
+import { resolveCliContext } from "../preflight/index.js";
+import { renderCliError } from "../render/utils/errors.js";
+import { colorize } from "../utils/colors.js";
+import { isInteractiveShell } from "../utils/terminal.js";
+import { createConfirmationWorkflow } from "./confirmation.js";
+import { NonInteractiveShellError } from "./errors.js";
+import { writeCommandOutput } from "./output.js";
+export async function runDoctorCommand(options = {}) {
+    const { writeOutput = writeCommandOutput } = options;
+    const { root } = await resolveCliContext({ requireWorkspace: false });
+    const diagnosis = await executeDoctorDiagnosis({ root });
+    if (options.fix) {
+        if (diagnosis.healthy) {
+            return {
+                body: renderHealthyDoctorBody(),
+                exitCode: 0,
+            };
+        }
+        const assumeYes = !isInteractiveShell();
+        const confirmation = createConfirmationWorkflow({
+            assumeYes,
+            onUnavailable: () => {
+                throw new NonInteractiveShellError();
+            },
+        });
+        try {
+            const mode = await resolveDoctorFixMode(root);
+            writeOutput({
+                alerts: [
+                    {
+                        severity: "info",
+                        message: renderDoctorFixPathMessage(mode),
+                    },
+                ],
+            });
+            await executeDoctorFix({
+                root,
+                mode,
+                bootstrapOptions: {
+                    preset: "pro",
+                    interactive: confirmation.interactive,
+                    assumeYes,
+                    confirm: confirmation.confirm,
+                    prompt: confirmation.prompt,
+                },
+            });
+            const postFixDiagnosis = await executeDoctorDiagnosis({ root });
+            if (postFixDiagnosis.healthy) {
+                return {
+                    body: renderHealthyDoctorBody(),
+                    exitCode: 0,
+                };
+            }
+            return {
+                body: renderDoctorIssues(postFixDiagnosis),
+                exitCode: 1,
+            };
+        }
+        finally {
+            confirmation.close();
+        }
+    }
+    if (diagnosis.healthy) {
+        return {
+            body: renderHealthyDoctorBody(),
+            exitCode: 0,
+        };
+    }
+    return {
+        body: renderDoctorIssues(diagnosis),
+        exitCode: 1,
+    };
+}
+export function createDoctorCommand() {
+    return new Command("doctor")
+        .description("Diagnose workspace and preflight setup issues")
+        .option("--fix", "Apply safe workspace and managed-config repairs")
+        .allowExcessArguments(false)
+        .action(async (options) => {
+        const result = await runDoctorCommand({
+            fix: Boolean(options.fix),
+        });
+        writeCommandOutput({
+            body: result.body,
+            exitCode: result.exitCode,
+        });
+    });
+}
+function renderDoctorFixPathMessage(mode) {
+    if (mode === "bootstrap-workspace") {
+        return "Workspace missing. This will bootstrap workspace and managed config.";
+    }
+    return "Workspace found. This will repair structure and reconcile managed config.";
+}
+function renderHealthyDoctorBody() {
+    return [
+        colorize("Workspace healthy, no issues found.", "green"),
+        "",
+        "Still having issues? Please reach out to support@voratiq.com.",
+    ].join("\n");
+}
+function renderDoctorIssues(diagnosis) {
+    const detailLines = diagnosis.issueLines.length > 1 ? diagnosis.issueLines : [];
+    const headline = diagnosis.issueLines.length === 1
+        ? stripDoctorIssuePrefix(diagnosis.issueLines[0] ?? "Workspace check failed.")
+        : "Workspace check failed.";
+    return renderCliError(new CliError(headline, detailLines, [PREFLIGHT_HINT]));
+}
+function stripDoctorIssuePrefix(line) {
+    return line.replace(/^- /u, "").trim();
+}

package/dist/cli/list.js

@@ -2,7 +2,7 @@ import { Command } from "commander";
 import { executeListCommand } from "../commands/list/command.js";
 import { resolveCliContext } from "../preflight/index.js";
 import { parsePositiveInteger } from "../utils/validators.js";
-import { resolveWorkspacePath, VORATIQ_MESSAGE_FILE, VORATIQ_REDUCTION_FILE, VORATIQ_VERIFICATION_FILE, } from "../workspace/structure.js";
+import { resolveWorkspacePath, VORATIQ_INTERACTIVE_FILE, VORATIQ_MESSAGE_FILE, VORATIQ_REDUCTION_FILE, VORATIQ_VERIFICATION_FILE, } from "../workspace/structure.js";
 import { parseListInspectionCommandOptions } from "./contract.js";
 import { writeCommandOutput } from "./output.js";
 export async function runListCommand(options) {
@@ -19,6 +19,8 @@ export async function runListCommand(options) {
             resolveWorkspacePath(root, VORATIQ_MESSAGE_FILE),
         verificationsFilePath: workspacePaths.verificationsFile ??
             resolveWorkspacePath(root, VORATIQ_VERIFICATION_FILE),
+        interactiveFilePath: workspacePaths.interactiveFile ??
+            resolveWorkspacePath(root, VORATIQ_INTERACTIVE_FILE),
         operator: options.operator,
         sessionId: options.sessionId,
         limit: options.limit,
@@ -45,6 +47,7 @@ export function createListCommand() {
         .option("--reduce [session-id]", "List reduction sessions or show one reduction session")
         .option("--verify [session-id]", "List verification sessions or show one verification session")
         .option("--message [session-id]", "List message sessions or show one message session")
+        .option("--interactive [session-id]", "List interactive sessions or show one interactive session")
         .option("--limit <count>", "Show only the N most recent sessions (default: 10)", parseLimitOption)
         .option("--verbose", "Show all statuses for the selected operator in table mode")
         .option("--json", "Emit machine-readable list output")

package/dist/cli/operator-envelope.d.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import type { ReductionTarget } from "../domain/reduce/model/types.js";
+import type { RunSpecTarget } from "../domain/run/model/types.js";
 import type { SelectionDecision } from "../policy/index.js";
 import type { ReductionStatus, RunStatus, VerificationStatus } from "../status/index.js";
 import { externalExecutionOperators } from "./contract.js";
@@ -11,6 +12,20 @@ export interface EnvelopeArtifactRef {
     role?: string;
     agentId?: string;
 }
+export interface EnvelopeTargetRef {
+    kind: string;
+    sessionId: string;
+    lineage?: string;
+    issueCode?: string;
+    currentContentHash?: string;
+    source?: {
+        kind?: string;
+        sessionId?: string;
+        agentId?: string;
+        outputPath?: string;
+        contentHash?: string;
+    };
+}
 export interface OperatorResultEnvelope {
     version: 1;
     operator: EnvelopeOperator;
@@ -24,10 +39,7 @@ export interface OperatorResultEnvelope {
         messageId?: string;
         agentId?: string;
     };
-    target?: {
-        kind: string;
-        sessionId: string;
-    };
+    target?: EnvelopeTargetRef;
     artifacts: EnvelopeArtifactRef[];
     selection?: {
         state: "resolvable" | "unresolved";
@@ -51,9 +63,9 @@ export declare const operatorResultEnvelopeSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     operator: z.ZodEnum<{
         message: "message";
+        spec: "spec";
         reduce: "reduce";
         apply: "apply";
-        spec: "spec";
         run: "run";
         verify: "verify";
         prune: "prune";
@@ -114,7 +126,7 @@ export interface VerifyEnvelopeInput {
         sessionId: string;
     };
     outputPath: string;
-    status: VerificationStatus;
+    status: VerificationStatus | "unresolved";
     selection?: SelectionDecision;
     selectedSpecPath?: string;
     warningMessage?: string;
@@ -166,6 +178,7 @@ export declare function buildSpecOperatorEnvelope(options: {
 export declare function buildRunOperatorEnvelope(options: {
     runId: string;
     specPath: string;
+    specTarget?: RunSpecTarget;
     status: RunStatus;
 }): OperatorResultEnvelope;
 export declare function buildVerifyOperatorEnvelope(options: VerifyEnvelopeInput): OperatorResultEnvelope;