voratiq 0.1.0-beta.21 → 0.1.0-beta.22

package/dist/domain/run/model/types.js

@@ -5,8 +5,95 @@ import { repoRelativeRecordPathSchema } from "../../../persistence/record-path-s
 import { agentStatusSchema, applyStatusSchema as applyStatusValueSchema, IN_PROGRESS_AGENT_STATUSES, runStatusSchema, TERMINAL_AGENT_STATUSES, TERMINAL_RUN_STATUSES, } from "../../../status/index.js";
 import { validateOperationLifecycleTimestamps, validateRecordLifecycleTimestamps, } from "../../shared/lifecycle.js";
 export { agentStatusSchema, IN_PROGRESS_AGENT_STATUSES, TERMINAL_AGENT_STATUSES, };
+const RUN_SPEC_TARGET_KIND_VALUES = ["file", "spec"];
+const RUN_SPEC_PROVENANCE_LINEAGE_VALUES = [
+    "exact",
+    "derived",
+    "derived_modified",
+    "invalid",
+];
+const RUN_SPEC_PROVENANCE_ISSUE_VALUES = [
+    "malformed_frontmatter",
+    "stale_source",
+];
+export const runSpecTargetKindSchema = z.enum(RUN_SPEC_TARGET_KIND_VALUES);
+export const runSpecProvenanceLineageSchema = z.enum(RUN_SPEC_PROVENANCE_LINEAGE_VALUES);
+export const runSpecProvenanceIssueSchema = z.enum(RUN_SPEC_PROVENANCE_ISSUE_VALUES);
+export const runSpecContentHashSchema = z
+    .string()
+    .regex(/^sha256:[a-f0-9]{64}$/u);
+export const runSpecSourceDescriptorSchema = z
+    .object({
+    kind: z.literal("spec"),
+    sessionId: z.string().min(1),
+    agentId: agentIdSchema,
+    outputPath: repoRelativeRecordPathSchema,
+    contentHash: runSpecContentHashSchema,
+})
+    .strict();
+export const runSpecSourceHintSchema = z
+    .object({
+    kind: z.literal("spec").optional(),
+    sessionId: z.string().min(1).optional(),
+    agentId: agentIdSchema.optional(),
+    outputPath: repoRelativeRecordPathSchema.optional(),
+    contentHash: runSpecContentHashSchema.optional(),
+})
+    .strict();
+export const exactRunSpecProvenanceSchema = z
+    .object({
+    lineage: z.literal("exact"),
+    source: runSpecSourceDescriptorSchema.optional(),
+})
+    .strict();
+export const derivedRunSpecProvenanceSchema = z
+    .object({
+    lineage: z.literal("derived"),
+    source: runSpecSourceDescriptorSchema,
+    currentContentHash: runSpecContentHashSchema,
+})
+    .strict();
+export const derivedModifiedRunSpecProvenanceSchema = z
+    .object({
+    lineage: z.literal("derived_modified"),
+    source: runSpecSourceDescriptorSchema,
+    currentContentHash: runSpecContentHashSchema,
+})
+    .strict();
+export const invalidRunSpecProvenanceSchema = z
+    .object({
+    lineage: z.literal("invalid"),
+    issueCode: runSpecProvenanceIssueSchema,
+    source: runSpecSourceHintSchema.optional(),
+    currentContentHash: runSpecContentHashSchema.optional(),
+})
+    .strict();
+export const runSpecProvenanceSchema = z.union([
+    exactRunSpecProvenanceSchema,
+    derivedRunSpecProvenanceSchema,
+    derivedModifiedRunSpecProvenanceSchema,
+    invalidRunSpecProvenanceSchema,
+]);
+export const fileRunSpecTargetSchema = z
+    .object({
+    kind: z.literal("file"),
+    provenance: invalidRunSpecProvenanceSchema.optional(),
+})
+    .strict();
+export const sessionRunSpecTargetSchema = z
+    .object({
+    kind: z.literal("spec"),
+    sessionId: z.string().min(1),
+    provenance: runSpecProvenanceSchema.optional(),
+})
+    .strict();
+export const runSpecTargetSchema = z.union([
+    fileRunSpecTargetSchema,
+    sessionRunSpecTargetSchema,
+]);
 export const runSpecDescriptorSchema = z.object({
     path: repoRelativeRecordPathSchema,
+    target: runSpecTargetSchema.optional(),
 });
 const CHAT_ARTIFACT_FORMATS = [
     "json",

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

@@ -15,6 +15,7 @@ export interface SpecCompetitionExecution {
     readonly agentId: string;
     readonly outputPath?: string;
     readonly dataPath?: string;
+    readonly contentHash?: `sha256:${string}`;
     readonly status: "succeeded" | "failed";
     readonly tokenUsage?: ExtractedTokenUsage;
     readonly tokenUsageResult: TokenUsageResult;

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

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { detectAgentProcessFailureDetail } from "../../../agents/runtime/failures.js";
@@ -138,7 +139,7 @@ export function createSpecCompetitionAdapter(input) {
                 }
                 const stagedMarkdownPath = join(workspacePaths.workspacePath, SPEC_MARKDOWN_FILENAME);
                 const stagedDataPath = join(workspacePaths.workspacePath, SPEC_DATA_FILENAME);
-                await readFile(stagedMarkdownPath, "utf8");
+                const markdownContent = await readFile(stagedMarkdownPath, "utf8");
                 const specData = parseSpecData(await readFile(stagedDataPath, "utf8"));
                 const artifactBasename = slugify(specData.title, "spec");
                 const artifactMarkdownFilename = `${artifactBasename}.md`;
@@ -161,6 +162,7 @@ export function createSpecCompetitionAdapter(input) {
                     agentId: candidate.id,
                     outputPath: normalizePathForDisplay(relativeToRoot(root, markdownPromoteResult.artifactPath)),
                     dataPath: normalizePathForDisplay(relativeToRoot(root, dataPromoteResult.artifactPath)),
+                    contentHash: hashSpecContent(markdownContent),
                     status: "succeeded",
                     tokenUsage,
                     tokenUsageResult,
@@ -194,3 +196,6 @@ function registerScratchWorkspaceTeardown(teardown, workspacePaths, agentId) {
 function compareSpecExecutionsByAgentId(left, right) {
     return left.agentId.localeCompare(right.agentId);
 }
+function hashSpecContent(content) {
+    return `sha256:${createHash("sha256").update(content, "utf8").digest("hex")}`;
+}

package/dist/domain/spec/model/types.d.ts

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { type SpecAgentStatus, specAgentStatusSchema, type SpecRecordStatus, specRecordStatusSchema, TERMINAL_SPEC_AGENT_STATUSES, TERMINAL_SPEC_STATUSES } from "../../../status/index.js";
 export type { SpecAgentStatus, SpecRecordStatus };
 export { specAgentStatusSchema, specRecordStatusSchema, TERMINAL_SPEC_AGENT_STATUSES, TERMINAL_SPEC_STATUSES, };
+export declare const specContentHashSchema: z.ZodString;
 export declare const specAgentEntrySchema: z.ZodObject<{
     agentId: z.ZodString;
     status: z.ZodEnum<{
@@ -14,6 +15,7 @@ export declare const specAgentEntrySchema: z.ZodObject<{
     completedAt: z.ZodOptional<z.ZodString>;
     outputPath: z.ZodOptional<z.ZodString>;
     dataPath: z.ZodOptional<z.ZodString>;
+    contentHash: z.ZodOptional<z.ZodString>;
     tokenUsage: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
         input_tokens: z.ZodOptional<z.ZodNumber>;
         output_tokens: z.ZodOptional<z.ZodNumber>;
@@ -66,6 +68,7 @@ export declare const specRecordSchema: z.ZodObject<{
         completedAt: z.ZodOptional<z.ZodString>;
         outputPath: z.ZodOptional<z.ZodString>;
         dataPath: z.ZodOptional<z.ZodString>;
+        contentHash: z.ZodOptional<z.ZodString>;
         tokenUsage: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
             input_tokens: z.ZodOptional<z.ZodNumber>;
             output_tokens: z.ZodOptional<z.ZodNumber>;

package/dist/domain/spec/model/types.js

@@ -9,6 +9,10 @@ export { specAgentStatusSchema, specRecordStatusSchema, TERMINAL_SPEC_AGENT_STAT
 const IN_PROGRESS_SPEC_STATUSES = [
     "running",
 ];
+const SPEC_CONTENT_HASH_PATTERN = /^sha256:[a-f0-9]{64}$/u;
+export const specContentHashSchema = z
+    .string()
+    .regex(SPEC_CONTENT_HASH_PATTERN);
 export const specAgentEntrySchema = z
     .object({
     agentId: agentIdSchema,
@@ -17,6 +21,7 @@ export const specAgentEntrySchema = z
     completedAt: z.string().optional(),
     outputPath: repoRelativeRecordPathSchema.optional(),
     dataPath: repoRelativeRecordPathSchema.optional(),
+    contentHash: specContentHashSchema.optional(),
     tokenUsage: extractedTokenUsageSchema.optional(),
     error: z.string().nullable().optional(),
 })

package/dist/domain/verify/competition/finalize.d.ts

@@ -1,5 +1,14 @@
 import type { VerificationMethodResultRef, VerificationStatus } from "../model/types.js";
 import type { ResolvedVerificationTarget } from "./target.js";
+/**
+ * Derive the session-level verification status from per-method outcomes.
+ *
+ * Session status is "succeeded" when at least one terminal method succeeds.
+ * Session status is "aborted" only when all terminal methods are aborted.
+ * Otherwise, the session is treated as "failed". When no terminal method
+ * snapshots exist yet, preserve the historical default of reporting
+ * "succeeded" rather than manufacturing a failure.
+ */
 export declare function deriveVerificationStatusFromMethods(methods: readonly VerificationMethodResultRef[]): VerificationStatus;
 export declare function maybePersistSelectedSpecPath(options: {
     root: string;

package/dist/domain/verify/competition/finalize.js

@@ -1,12 +1,31 @@
 import { loadVerificationSelectionPolicyOutput } from "../../../policy/index.js";
 import { rewriteVerificationRecord } from "../persistence/adapter.js";
+/**
+ * Derive the session-level verification status from per-method outcomes.
+ *
+ * Session status is "succeeded" when at least one terminal method succeeds.
+ * Session status is "aborted" only when all terminal methods are aborted.
+ * Otherwise, the session is treated as "failed". When no terminal method
+ * snapshots exist yet, preserve the historical default of reporting
+ * "succeeded" rather than manufacturing a failure.
+ */
 export function deriveVerificationStatusFromMethods(methods) {
-    if (methods.some((method) => method.status === "failed")) {
-        return "failed";
+    const terminalMethods = methods.filter((method) => method.status === "succeeded" ||
+        method.status === "failed" ||
+        method.status === "aborted");
+    const hasSucceeded = terminalMethods.some((method) => method.status === "succeeded");
+    if (hasSucceeded) {
+        return "succeeded";
     }
-    if (methods.some((method) => method.status === "aborted")) {
+    const hasTerminalMethods = terminalMethods.length > 0;
+    const allTerminalAborted = hasTerminalMethods &&
+        terminalMethods.every((method) => method.status === "aborted");
+    if (allTerminalAborted) {
         return "aborted";
     }
+    if (terminalMethods.some((method) => method.status === "failed")) {
+        return "failed";
+    }
     return "succeeded";
 }
 export async function maybePersistSelectedSpecPath(options) {

package/dist/domain/verify/model/types.d.ts

@@ -11,8 +11,8 @@ export type VerificationMethodKind = (typeof VERIFICATION_METHOD_KIND_VALUES)[nu
 export type VerificationScopeKind = (typeof VERIFICATION_SCOPE_KIND_VALUES)[number];
 export declare const verificationTargetKindSchema: z.ZodEnum<{
     message: "message";
-    reduce: "reduce";
     spec: "spec";
+    reduce: "reduce";
     run: "run";
 }>;
 export declare const verificationMethodKindSchema: z.ZodEnum<{
@@ -399,8 +399,8 @@ export declare const verificationIndexEntrySchema: z.ZodObject<{
     }>;
     targetKind: z.ZodEnum<{
         message: "message";
-        reduce: "reduce";
         spec: "spec";
+        reduce: "reduce";
         run: "run";
     }>;
     targetSessionId: z.ZodString;

package/dist/interactive/providers/mcp.d.ts

@@ -6,6 +6,7 @@ export interface FirstPartyMcpStatusAndArgs {
 }
 export declare function resolveFirstPartyMcpStatus(options: {
     providerId: FirstPartyProviderId;
+    providerBinary?: string;
     root: string;
     toolDeclarations: readonly NativeToolDeclaration[];
     promptForMcpInstall?: PromptForMcpInstall;

package/dist/interactive/providers/mcp.js

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { basename } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 import { loadRepoSettings } from "../../configs/settings/loader.js";
 import { BUNDLED_VORATIQ_TOOL_TARGET_NAME, } from "./shared.js";
@@ -44,9 +45,11 @@ export async function resolveFirstPartyMcpStatus(options) {
     }
     const runCommand = options.mcpCommandRunner ?? runProviderMcpCommand;
     const adapter = firstPartyMcpAdapters[options.providerId];
+    const providerBinary = resolveProviderBinary(options.providerBinary, adapter.providerCommand);
     const initialInspection = summarizeFirstPartyMcpInspection({
         toolDeclarations: options.toolDeclarations,
         inspections: await adapter.inspectTools({
+            providerBinary,
             root: options.root,
             toolDeclarations: options.toolDeclarations,
             runCommand,
@@ -84,12 +87,14 @@ export async function resolveFirstPartyMcpStatus(options) {
     }
     await installVoratiqMcpForProvider({
         adapter,
+        providerBinary,
         root: options.root,
         toolDeclarations: initialInspection.missingToolDeclarations,
         runCommand,
     });
     const verifiedInspection = await verifyFirstPartyMcpStatus({
         adapter,
+        providerBinary,
         root: options.root,
         toolDeclarations: options.toolDeclarations,
         runCommand,
@@ -141,6 +146,7 @@ async function verifyFirstPartyMcpStatus(options) {
         lastSummary = summarizeFirstPartyMcpInspection({
             toolDeclarations: options.toolDeclarations,
             inspections: await options.adapter.inspectTools({
+                providerBinary: options.providerBinary,
                 root: options.root,
                 toolDeclarations: options.toolDeclarations,
                 runCommand: options.runCommand,
@@ -176,7 +182,7 @@ async function inspectGeminiMcpTools(options) {
         return inspections;
     }
     const result = await options.runCommand({
-        command: "gemini",
+        command: options.providerBinary,
         args: ["mcp", "list"],
         cwd: options.root,
     });
@@ -203,6 +209,7 @@ async function inspectCliMcpToolsViaGet(options) {
     const inspections = new Map();
     for (const tool of options.toolDeclarations) {
         inspections.set(tool.name, await inspectCliMcpTool({
+            providerBinary: options.providerBinary,
             providerCommand: options.providerCommand,
             root: options.root,
             declaration: tool,
@@ -213,6 +220,7 @@ async function inspectCliMcpToolsViaGet(options) {
 }
 async function inspectCodexMcpTools(options) {
     return await inspectCliMcpToolsViaGet({
+        providerBinary: options.providerBinary,
         providerCommand: "codex",
         root: options.root,
         toolDeclarations: options.toolDeclarations,
@@ -221,6 +229,7 @@ async function inspectCodexMcpTools(options) {
 }
 async function inspectClaudeMcpTools(options) {
     return await inspectCliMcpToolsViaGet({
+        providerBinary: options.providerBinary,
         providerCommand: "claude",
         root: options.root,
         toolDeclarations: options.toolDeclarations,
@@ -230,7 +239,7 @@ async function inspectClaudeMcpTools(options) {
 async function inspectCliMcpTool(options) {
     if (options.providerCommand === "codex") {
         const result = await options.runCommand({
-            command: "codex",
+            command: options.providerBinary,
             args: ["mcp", "get", "--json", options.declaration.name],
             cwd: options.root,
         });
@@ -260,7 +269,7 @@ async function inspectCliMcpTool(options) {
             };
     }
     const result = await options.runCommand({
-        command: "claude",
+        command: options.providerBinary,
         args: ["mcp", "get", options.declaration.name],
         cwd: options.root,
     });
@@ -345,11 +354,11 @@ function normalizeStringArray(value) {
     return [...value];
 }
 function matchesDeclarationCommandAndArgs(declaration, value) {
-    if (value.command !== declaration.command) {
+    const expectedArgs = declaration.args ? [...declaration.args] : [];
+    if (!areStringArraysEqual(value.args, expectedArgs)) {
         return false;
     }
-    const expectedArgs = declaration.args ? [...declaration.args] : [];
-    return areStringArraysEqual(value.args, expectedArgs);
+    return areEquivalentMcpCommands(value.command, declaration.command);
 }
 function areStringArraysEqual(left, right) {
     if (left.length !== right.length) {
@@ -362,6 +371,16 @@ function areStringArraysEqual(left, right) {
     }
     return true;
 }
+function areEquivalentMcpCommands(left, right) {
+    if (left === right) {
+        return true;
+    }
+    return isNodeExecutableCommand(left) && isNodeExecutableCommand(right);
+}
+function isNodeExecutableCommand(value) {
+    const normalized = basename(value).toLowerCase();
+    return normalized === "node" || normalized === "node.exe";
+}
 function buildCommandMismatchDetail(declaration, actual) {
     return [
         `Expected \`${formatCommandAndArgs(declaration.command, declaration.args ?? [])}\`,`,
@@ -425,7 +444,7 @@ function splitCommandLine(value) {
 async function installVoratiqMcpForProvider(options) {
     for (const toolDeclaration of options.toolDeclarations) {
         const result = await options.runCommand({
-            command: options.adapter.providerCommand,
+            command: options.providerBinary,
             args: options.adapter.buildAddArgs(toolDeclaration),
             cwd: options.root,
         });
@@ -535,7 +554,22 @@ async function runProviderMcpCommand(input) {
         stderr += chunk;
     });
     const exitCode = await new Promise((resolve) => {
+        let settled = false;
+        child.on("error", (error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            if (stderr.trim().length === 0) {
+                stderr = error.message;
+            }
+            resolve(null);
+        });
         child.on("close", (code) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
             resolve(typeof code === "number" ? code : null);
         });
     });
@@ -545,3 +579,7 @@ async function runProviderMcpCommand(input) {
         stderr,
     };
 }
+function resolveProviderBinary(candidate, fallback) {
+    const normalized = candidate?.trim();
+    return normalized && normalized.length > 0 ? normalized : fallback;
+}

package/dist/interactive/substrate.js

@@ -6,7 +6,7 @@ import process from "node:process";
 import { collectProviderArtifacts, prepareProviderArtifactCaptureContext, } from "../agents/launch/chat.js";
 import { writeStagedPrompt } from "../agents/launch/prompt.js";
 import { resolveAgentProviderForDefinition } from "../agents/launch/provider-state.js";
-import { clearActiveInteractive, finalizeActiveInteractive, registerActiveInteractive, } from "../commands/interactive/lifecycle.js";
+import { clearActiveInteractive, finalizeActiveInteractive, getActiveInteractiveTerminationStatus, registerActiveInteractive, } from "../commands/interactive/lifecycle.js";
 import { createTeardownController, runTeardown, } from "../competition/shared/teardown.js";
 import { AgentBinaryAccessError, AgentBinaryMissingError, AgentDisabledError, AgentNotFoundError, } from "../configs/agents/errors.js";
 import { loadAgentById } from "../configs/agents/loader.js";
@@ -14,6 +14,7 @@ import { resolveFirstPartyLaunchPrompt } from "../domain/interactive/prompt.js";
 import { toErrorMessage } from "../utils/errors.js";
 import { isMissing } from "../utils/fs.js";
 import { generateSessionId } from "../utils/session-id.js";
+import { normalizeInteractiveTerm } from "../utils/terminal.js";
 import { resolveVoratiqCliTarget } from "../utils/voratiq-cli-target.js";
 import { createBundledVoratiqToolDeclaration, prepareProviderNativeLaunch, resolveFirstPartyMcpStatus, } from "./providers.js";
 import { appendInteractiveSessionRecord, ensureInteractiveSessionDirectories, resolveInteractiveSessionPaths, rewriteInteractiveSessionRecord, toInteractiveSessionRelativePath, } from "./records.js";
@@ -127,6 +128,7 @@ export async function prepareNativeInteractiveSession(options) {
             try {
                 firstPartyMcpResolution = await resolveFirstPartyMcpStatus({
                     providerId,
+                    providerBinary: agent.binary,
                     root: options.root,
                     toolDeclarations,
                     promptForMcpInstall: options.promptForMcpInstall,
@@ -191,6 +193,13 @@ export async function prepareNativeInteractiveSession(options) {
                 providerId,
                 sessionRoot: paths.sessionRoot,
                 searchEnv: invocationEnv,
+                selectionHint: providerId === "codex"
+                    ? {
+                        strategy: "codex-session-meta",
+                        cwd: cwd.path,
+                        minStartedAt: createdAt,
+                    }
+                    : undefined,
             });
         }
         catch {
@@ -251,9 +260,15 @@ export async function spawnPreparedInteractiveSession(prepared, options = {}) {
     if (stdio === "inherit") {
         process.stdout.write("\n");
     }
+    const spawnEnv = stdio === "inherit"
+        ? {
+            ...prepared.invocation.env,
+            TERM: normalizeInteractiveTerm(prepared.invocation.env),
+        }
+        : prepared.invocation.env;
     const child = spawn(prepared.invocation.command, prepared.invocation.args, {
         cwd: prepared.invocation.cwd,
-        env: prepared.invocation.env,
+        env: spawnEnv,
         stdio,
     });
     const completion = createProcessCompletionPromise(prepared, child);
@@ -321,9 +336,11 @@ function createProcessCompletionPromise(prepared, child) {
                 return;
             }
             finalized = true;
+            const terminationStatus = getActiveInteractiveTerminationStatus(prepared.sessionId);
+            const signalCountsAsSuccess = terminationStatus === "aborted" && options.signal !== null;
             const runtimeFailureMessage = options.spawnError
                 ? `Failed during provider execution: ${options.spawnError.message}`
-                : options.signal
+                : options.signal && !signalCountsAsSuccess
                     ? `Provider process terminated by signal ${options.signal}`
                     : options.exitCode && options.exitCode !== 0
                         ? `Provider process exited with code ${options.exitCode}`

package/dist/mcp/server.js

@@ -1,9 +1,9 @@
 import { spawn } from "node:child_process";
 import process from "node:process";
 import { z } from "zod";
-import { externalApplyExecutionInputSchema, externalListInspectionInputSchema, externalMessageExecutionInputSchema, externalPruneExecutionInputSchema, externalReduceExecutionInputSchema, externalRunExecutionInputSchema, externalSpecExecutionInputSchema, externalVerifyExecutionInputSchema, } from "../cli/contract.js";
+import { externalApplyExecutionInputSchema, externalInspectionOperatorSchema, externalMessageExecutionInputSchema, externalPruneExecutionInputSchema, externalReduceExecutionInputSchema, externalRunExecutionInputSchema, externalSpecExecutionInputSchema, externalVerifyExecutionInputSchema, } from "../cli/contract.js";
 import { operatorResultEnvelopeSchema, } from "../cli/operator-envelope.js";
-import { listJsonOutputSchema, } from "../contracts/list.js";
+import { listJsonModes, listJsonModeSchema, listJsonOutputSchema, } from "../contracts/list.js";
 import { getVoratiqVersion } from "../utils/version.js";
 import { createEntrypointVoratiqCliTarget as createEntrypointCliTarget, resolveVoratiqCliTarget, } from "../utils/voratiq-cli-target.js";
 const JSON_RPC_VERSION = "2.0";
@@ -23,6 +23,25 @@ export const VORATIQ_SUPPORTED_MCP_PROTOCOL_VERSIONS = [
 function isSupportedMcpProtocolVersion(protocolVersion) {
     return VORATIQ_SUPPORTED_MCP_PROTOCOL_VERSIONS.includes(protocolVersion);
 }
+const mcpListInspectionInputSchema = z.discriminatedUnion("mode", [
+    z
+        .object({
+        operator: externalInspectionOperatorSchema,
+        mode: z.literal(listJsonModes[0]),
+        verbose: z.boolean().optional(),
+        limit: z.number().int().positive().optional(),
+    })
+        .strict(),
+    z
+        .object({
+        operator: externalInspectionOperatorSchema,
+        mode: z.literal(listJsonModes[1]),
+        sessionId: z.string().min(1),
+        verbose: z.boolean().optional(),
+        limit: z.number().int().positive().optional(),
+    })
+        .strict(),
+]);
 const initializeRequestParamsSchema = z
     .object({
     protocolVersion: z.string(),
@@ -86,8 +105,8 @@ const toolSpecs = [
     {
         name: "voratiq_list",
         operator: "list",
-        description: "List recorded Voratiq sessions for one operator (`spec`, `run`, `reduce`, `verify`, or `message`) in table or detail mode.",
-        inputSchemaSource: externalListInspectionInputSchema,
+        description: "List recorded Voratiq sessions for one operator (`spec`, `run`, `reduce`, `verify`, `message`, or `interactive`) in list or detail mode.",
+        inputSchemaSource: mcpListInspectionInputSchema,
         mcpInputSchema: createListMcpInputSchema(),
         buildArgs: (input) => buildListInspectionArgs(input),
         outputContract: "list",
@@ -107,7 +126,7 @@ const toolDefinitions = toolSpecs.map((tool) => ({
     description: tool.description,
     inputSchema: tool.mcpInputSchema ?? toToolInputJsonSchema(tool.inputSchemaSource),
 }));
-const VORATIQ_MCP_SERVER_INSTRUCTIONS = "Voratiq tools operate on Voratiq workflow state in the current repository. Use voratiq_list for questions about recent or specific spec, run, reduce, verify, or message sessions. Use voratiq_spec, voratiq_run, voratiq_reduce, voratiq_verify, voratiq_message, voratiq_apply, and voratiq_prune for the normal Voratiq workflow. Prefer these tools over shell inspection when the task is about Voratiq workflow history or state.";
+const VORATIQ_MCP_SERVER_INSTRUCTIONS = "Voratiq tools operate on Voratiq workflow state in the current repository. Use voratiq_list for questions about recent or specific spec, run, reduce, verify, message, or interactive sessions. Use voratiq_spec, voratiq_run, voratiq_reduce, voratiq_verify, voratiq_message, voratiq_apply, and voratiq_prune for the normal Voratiq workflow. Prefer these tools over shell inspection when the task is about Voratiq workflow history or state.";
 const toolSpecsByName = new Map(toolSpecs.map((tool) => [tool.name, tool]));
 export function getVoratiqMcpToolDefinitions() {
     return toolDefinitions;
@@ -573,10 +592,8 @@ function createPruneMcpInputSchema() {
 function createListMcpInputSchema() {
     return toToolInputJsonSchema(z
         .object({
-        operator: z.enum(["spec", "run", "reduce", "verify", "message"]),
-        mode: z
-            .enum(["table", "detail"])
-            .describe("Use `detail` only when inspecting a specific session."),
+        operator: externalInspectionOperatorSchema,
+        mode: listJsonModeSchema.describe("Use `detail` only when inspecting a specific session."),
         sessionId: z
             .string()
             .min(1)

package/dist/policy/verification.js

@@ -208,7 +208,7 @@ async function readArtifactJson(options) {
 }
 function buildVerificationSelectionVerifiers(options) {
     const participatingRubrics = resolveWinnerPolicyParticipatingRubrics(options);
-    return participatingRubrics.map((rubric) => {
+    const verifiers = participatingRubrics.map((rubric) => {
         if (rubric.status !== "succeeded") {
             return {
                 verifierAgentId: rubric.verifierId,
@@ -223,6 +223,23 @@ function buildVerificationSelectionVerifiers(options) {
             ...(preferredCandidateId ? { preferredCandidateId } : {}),
         };
     });
+    const addedFailedVerifierIds = new Set(verifiers
+        .filter((verifier) => verifier.status === "failed")
+        .map((verifier) => verifier.verifierAgentId));
+    for (const rubric of options.policyInput.rubrics) {
+        if (rubric.status === "succeeded") {
+            continue;
+        }
+        if (addedFailedVerifierIds.has(rubric.verifierId)) {
+            continue;
+        }
+        verifiers.push({
+            verifierAgentId: rubric.verifierId,
+            status: "failed",
+        });
+        addedFailedVerifierIds.add(rubric.verifierId);
+    }
+    return verifiers;
 }
 function resolveVerificationWinnerPolicy(winnerPolicy) {
     return winnerPolicy ?? DEFAULT_VERIFICATION_WINNER_POLICY;

package/dist/preflight/agents.d.ts

@@ -0,0 +1,24 @@
+import type { PreflightIssue } from "../competition/shared/preflight.js";
+import type { AgentDefinition } from "../configs/agents/types.js";
+export interface CollectConfiguredAgentReadinessInput {
+    readonly root: string;
+    readonly resolvedAgentIds?: readonly string[];
+    readonly includeSettings?: boolean;
+}
+export interface ConfiguredAgentReadinessResult {
+    readonly agents: readonly AgentDefinition[];
+    readonly issues: readonly PreflightIssue[];
+    readonly preProviderIssueCount: number;
+    readonly noAgentsEnabled: boolean;
+}
+export interface CollectResolvedAgentReadinessInput {
+    readonly root: string;
+    readonly agents: readonly AgentDefinition[];
+    readonly includeSettings?: boolean;
+}
+export interface ResolvedAgentReadinessResult {
+    readonly issues: readonly PreflightIssue[];
+    readonly preProviderIssueCount: number;
+}
+export declare function collectConfiguredAgentReadiness(input: CollectConfiguredAgentReadinessInput): Promise<ConfiguredAgentReadinessResult>;
+export declare function collectResolvedAgentReadiness(input: CollectResolvedAgentReadinessInput): Promise<ResolvedAgentReadinessResult>;