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

package/dist/commands/message/command.js

@@ -0,0 +1,215 @@
+import { verifyAgentProviders } from "../../agents/runtime/auth.js";
+import { executeCompetitionWithAdapter } from "../../competition/command-adapter.js";
+import { createTeardownController } from "../../competition/shared/teardown.js";
+import { AgentNotFoundError } from "../../configs/agents/errors.js";
+import { loadEnvironmentConfig } from "../../configs/environment/loader.js";
+import { createMessageCompetitionAdapter, } from "../../domain/message/competition/adapter.js";
+import { createMessageRecordMutators } from "../../domain/message/model/mutators.js";
+import { deriveMessageStatusFromRecipients, } from "../../domain/message/model/types.js";
+import { appendMessageRecord, flushMessageRecordBuffer, } from "../../domain/message/persistence/adapter.js";
+import { buildPersistedExtraContextFields } from "../../extra-context/contract.js";
+import { toErrorMessage } from "../../utils/errors.js";
+import { getHeadRevision } from "../../utils/git.js";
+import { VORATIQ_MESSAGE_DIR, VORATIQ_REDUCTION_DIR, VORATIQ_RUN_DIR, VORATIQ_SPEC_DIR, VORATIQ_VERIFICATION_DIR, } from "../../workspace/structure.js";
+import { resolveEffectiveMaxParallel } from "../shared/max-parallel.js";
+import { resolveStageCompetitors } from "../shared/resolve-stage-competitors.js";
+import { generateSessionId } from "../shared/session-id.js";
+import { MessageAgentNotFoundError, MessageGenerationFailedError, MessageInvocationContextError, } from "./errors.js";
+import { finalizeActiveMessage, registerActiveMessage } from "./lifecycle.js";
+export async function executeMessageCommand(input) {
+    assertMessageInvocationContext();
+    const { root, messagesFilePath, prompt, agentIds, agentOverrideFlag, profileName, maxParallel: requestedMaxParallel, extraContextFiles = [], sourceInteractiveSessionId, renderer, } = input;
+    let competitors;
+    try {
+        const resolution = resolveStageCompetitors({
+            root,
+            stageId: "message",
+            cliAgentIds: agentIds,
+            cliOverrideFlag: agentOverrideFlag,
+            profileName,
+        });
+        competitors = resolution.competitors;
+    }
+    catch (error) {
+        if (error instanceof AgentNotFoundError) {
+            throw new MessageAgentNotFoundError(error.agentId);
+        }
+        throw error;
+    }
+    await assertMessagePreflight(competitors);
+    const environment = loadEnvironmentConfig({ root });
+    const baseRevisionSha = await getHeadRevision(root);
+    const messageId = generateSessionId();
+    const createdAt = new Date().toISOString();
+    const startedAt = createdAt;
+    const effectiveMaxParallel = resolveEffectiveMaxParallel({
+        competitorCount: competitors.length,
+        requestedMaxParallel,
+    });
+    const initialRecipients = competitors.map((agent) => ({
+        agentId: agent.id,
+        status: "queued",
+    }));
+    await appendMessageRecord({
+        root,
+        messagesFilePath,
+        record: {
+            sessionId: messageId,
+            createdAt,
+            startedAt,
+            status: "running",
+            baseRevisionSha,
+            prompt,
+            recipients: initialRecipients,
+            ...buildPersistedExtraContextFields(extraContextFiles),
+            ...(sourceInteractiveSessionId ? { sourceInteractiveSessionId } : {}),
+        },
+    });
+    renderer?.begin({
+        messageId,
+        createdAt,
+        startedAt,
+        workspacePath: `.voratiq/message/sessions/${messageId}`,
+        status: "running",
+    });
+    const teardown = createTeardownController(`message \`${messageId}\``);
+    registerActiveMessage({
+        root,
+        messagesFilePath,
+        messageId,
+        teardown,
+    });
+    const mutators = createMessageRecordMutators({
+        root,
+        messagesFilePath,
+        messageId,
+    });
+    let executions;
+    try {
+        const baseAdapter = createMessageCompetitionAdapter({
+            root,
+            messageId,
+            prompt,
+            environment,
+            extraContextFiles,
+            teardown,
+        });
+        executions = await executeCompetitionWithAdapter({
+            candidates: [...competitors],
+            maxParallel: effectiveMaxParallel,
+            adapter: {
+                ...baseAdapter,
+                onPreparationFailure: async (result) => {
+                    const recipient = toRecipientEntry(result);
+                    await mutators.recordRecipientSnapshot(recipient);
+                    renderer?.update(recipient);
+                },
+                onCandidateRunning: async (prepared) => {
+                    const runningAt = new Date().toISOString();
+                    const recipient = {
+                        agentId: prepared.candidate.id,
+                        status: "running",
+                        startedAt: runningAt,
+                    };
+                    await mutators.recordRecipientRunning(recipient);
+                    renderer?.update(recipient);
+                },
+                onCandidateCompleted: async (_prepared, result) => {
+                    const recipient = toRecipientEntry(result);
+                    await mutators.recordRecipientSnapshot(recipient);
+                    renderer?.update(recipient);
+                },
+            },
+        });
+        const persistedRecord = await mutators.readRecord();
+        if (!persistedRecord) {
+            throw new MessageGenerationFailedError([
+                `Message session \`${messageId}\` record not found after execution.`,
+            ]);
+        }
+        const status = deriveMessageStatusFromRecipients(persistedRecord.recipients.map((recipient) => recipient.status));
+        const completedRecord = await mutators.completeMessage({
+            status,
+            error: status === "failed"
+                ? collectRecipientErrors(persistedRecord.recipients)
+                : undefined,
+        });
+        await flushMessageRecordBuffer({
+            messagesFilePath,
+            sessionId: messageId,
+        });
+        renderer?.complete(completedRecord.status, {
+            startedAt: completedRecord.startedAt,
+            completedAt: completedRecord.completedAt,
+        });
+        return {
+            messageId,
+            record: completedRecord,
+            recipients: completedRecord.recipients,
+            executions,
+        };
+    }
+    catch (error) {
+        await mutators
+            .completeMessage({
+            status: "failed",
+            error: toErrorMessage(error),
+        })
+            .then((failedRecord) => {
+            renderer?.complete(failedRecord.status, {
+                startedAt: failedRecord.startedAt,
+                completedAt: failedRecord.completedAt,
+            });
+        })
+            .catch(() => {
+            renderer?.complete("failed");
+        });
+        await flushMessageRecordBuffer({
+            messagesFilePath,
+            sessionId: messageId,
+        }).catch(() => { });
+        throw new MessageGenerationFailedError([toErrorMessage(error)]);
+    }
+    finally {
+        await finalizeActiveMessage(messageId);
+    }
+}
+function toRecipientEntry(execution) {
+    return {
+        agentId: execution.agentId,
+        status: execution.status,
+        startedAt: execution.startedAt,
+        completedAt: execution.completedAt,
+        outputPath: execution.outputPath,
+        stdoutPath: execution.stdoutPath,
+        stderrPath: execution.stderrPath,
+        tokenUsage: execution.tokenUsage,
+        error: execution.error ?? null,
+    };
+}
+async function assertMessagePreflight(agents) {
+    const providerIssues = await verifyAgentProviders(agents.map((agent) => ({ id: agent.id, provider: agent.provider })));
+    if (providerIssues.length > 0) {
+        throw new MessageGenerationFailedError(providerIssues.map((issue) => `${issue.agentId}: ${issue.message}`));
+    }
+}
+function assertMessageInvocationContext() {
+    const cwd = process.cwd().replace(/\\/gu, "/");
+    const batchDomains = [
+        VORATIQ_SPEC_DIR,
+        VORATIQ_RUN_DIR,
+        VORATIQ_REDUCTION_DIR,
+        VORATIQ_VERIFICATION_DIR,
+        VORATIQ_MESSAGE_DIR,
+    ];
+    const batchWorkspacePattern = new RegExp(`/\\.voratiq/(?:${batchDomains.join("|")})/sessions/[^/]+/[^/]+/workspace(?:/|$)`, "u");
+    if (batchWorkspacePattern.test(cwd)) {
+        throw new MessageInvocationContextError();
+    }
+}
+function collectRecipientErrors(recipients) {
+    const details = recipients
+        .filter((recipient) => recipient.error)
+        .map((recipient) => `${recipient.agentId}: ${recipient.error}`);
+    return details.length > 0 ? details.join("; ") : undefined;
+}

package/dist/commands/message/errors.d.ts

@@ -0,0 +1,9 @@
+export declare class MessageAgentNotFoundError extends Error {
+    constructor(agentId: string);
+}
+export declare class MessageGenerationFailedError extends Error {
+    constructor(details: readonly string[]);
+}
+export declare class MessageInvocationContextError extends Error {
+    constructor();
+}

package/dist/commands/message/errors.js

@@ -0,0 +1,20 @@
+export class MessageAgentNotFoundError extends Error {
+    constructor(agentId) {
+        super(`Message agent not found: ${agentId}`);
+        this.name = "MessageAgentNotFoundError";
+    }
+}
+export class MessageGenerationFailedError extends Error {
+    constructor(details) {
+        super(details.length > 0
+            ? `Message execution failed: ${details.join("; ")}`
+            : "Message execution failed.");
+        this.name = "MessageGenerationFailedError";
+    }
+}
+export class MessageInvocationContextError extends Error {
+    constructor() {
+        super("`message` cannot be invoked from inside a batch agent workspace.");
+        this.name = "MessageInvocationContextError";
+    }
+}

package/dist/commands/message/lifecycle.d.ts

@@ -0,0 +1,14 @@
+import type { TeardownController } from "../../competition/shared/teardown.js";
+export declare const MESSAGE_ABORT_DETAIL = "Message generation aborted before completion.";
+export declare const MESSAGE_FAILURE_DETAIL = "Message generation failed.";
+interface ActiveMessageContext {
+    root: string;
+    messagesFilePath: string;
+    messageId: string;
+    teardown?: TeardownController;
+}
+export declare function registerActiveMessage(context: ActiveMessageContext): void;
+export declare function clearActiveMessage(messageId: string): void;
+export declare function terminateActiveMessage(status: "failed" | "aborted"): Promise<void>;
+export declare function finalizeActiveMessage(messageId: string): Promise<void>;
+export {};

package/dist/commands/message/lifecycle.js

@@ -0,0 +1,128 @@
+import { runTeardown } from "../../competition/shared/teardown.js";
+import { flushMessageRecordBuffer, readMessageRecords, rewriteMessageRecord, } from "../../domain/message/persistence/adapter.js";
+import { buildOperationLifecycleCompleteFields, buildRecordLifecycleCompleteFields, } from "../../domain/shared/lifecycle.js";
+import { toErrorMessage } from "../../utils/errors.js";
+export const MESSAGE_ABORT_DETAIL = "Message generation aborted before completion.";
+export const MESSAGE_FAILURE_DETAIL = "Message generation failed.";
+let activeMessage;
+let terminationInFlight = false;
+export function registerActiveMessage(context) {
+    activeMessage = context;
+}
+export function clearActiveMessage(messageId) {
+    if (activeMessage?.messageId !== messageId) {
+        return;
+    }
+    if (!terminationInFlight) {
+        activeMessage = undefined;
+    }
+}
+export async function terminateActiveMessage(status) {
+    if (!activeMessage || terminationInFlight) {
+        return;
+    }
+    terminationInFlight = true;
+    const context = activeMessage;
+    let persistenceError;
+    try {
+        const existingRecord = await readMessageRecords({
+            root: context.root,
+            messagesFilePath: context.messagesFilePath,
+            limit: 1,
+            predicate: (record) => record.sessionId === context.messageId,
+        }).then((records) => records[0]);
+        if (!existingRecord) {
+            return;
+        }
+        const completedAt = new Date().toISOString();
+        const detail = status === "aborted" ? MESSAGE_ABORT_DETAIL : MESSAGE_FAILURE_DETAIL;
+        await rewriteMessageRecord({
+            root: context.root,
+            messagesFilePath: context.messagesFilePath,
+            sessionId: context.messageId,
+            mutate: (existing) => {
+                const recipients = existing.recipients.map((recipient) => finalizeMessageRecipient({
+                    recipient,
+                    status,
+                    completedAt,
+                    detail,
+                }));
+                const inProgress = existing.status === "queued" || existing.status === "running";
+                if (!inProgress) {
+                    if (recipients.every((recipient, index) => recipient === existing.recipients[index])) {
+                        return existing;
+                    }
+                    return {
+                        ...existing,
+                        recipients,
+                    };
+                }
+                return {
+                    ...existing,
+                    status,
+                    recipients,
+                    ...buildRecordLifecycleCompleteFields({
+                        existing,
+                        startedAt: existing.startedAt ?? completedAt,
+                        completedAt,
+                    }),
+                    error: existing.error ?? detail,
+                };
+            },
+            forceFlush: true,
+        });
+        await flushMessageRecordBuffer({
+            messagesFilePath: context.messagesFilePath,
+            sessionId: context.messageId,
+        });
+    }
+    catch (error) {
+        persistenceError =
+            error instanceof Error ? error : new Error(toErrorMessage(error));
+        console.error(`[voratiq] Failed to finalize message ${context.messageId}: ${toErrorMessage(error)}`);
+    }
+    finally {
+        try {
+            await finalizeRegisteredMessageTeardown(context);
+        }
+        finally {
+            terminationInFlight = false;
+            activeMessage = undefined;
+        }
+    }
+    if (persistenceError) {
+        throw persistenceError;
+    }
+}
+export async function finalizeActiveMessage(messageId) {
+    if (!activeMessage || activeMessage.messageId !== messageId) {
+        clearActiveMessage(messageId);
+        return;
+    }
+    const context = activeMessage;
+    try {
+        await finalizeRegisteredMessageTeardown(context);
+    }
+    finally {
+        clearActiveMessage(messageId);
+    }
+}
+function finalizeMessageRecipient(options) {
+    const { recipient, status, completedAt, detail } = options;
+    if (recipient.status !== "queued" && recipient.status !== "running") {
+        return recipient;
+    }
+    return {
+        ...recipient,
+        status,
+        ...buildOperationLifecycleCompleteFields({
+            existing: recipient,
+            startedAt: recipient.startedAt ?? completedAt,
+            completedAt,
+        }),
+        error: recipient.error ?? detail,
+    };
+}
+async function finalizeRegisteredMessageTeardown(context) {
+    await runTeardown(context.teardown);
+}

package/dist/commands/prune/command.d.ts

@@ -1,2 +1,3 @@
-import type { PruneCommandInput, PruneResult } from "./types.js";
+import type { PruneAllCommandInput, PruneAllResult, PruneCommandInput, PruneResult } from "./types.js";
 export declare function executePruneCommand(input: PruneCommandInput): Promise<PruneResult>;
+export declare function executePruneAllCommand(input: PruneAllCommandInput): Promise<PruneAllResult>;

package/dist/commands/prune/command.js

@@ -1,14 +1,14 @@
 import * as fs from "node:fs/promises";
 import { NonInteractiveShellError } from "../../cli/errors.js";
-import { RunRecordNotFoundError, RunRecordParseError, } from "../../records/errors.js";
-import { rewriteRunRecord, RUN_RECORD_FILENAME, } from "../../records/persistence.js";
-import { buildPruneConfirmationPreface } from "../../render/transcripts/prune.js";
+import { RunRecordNotFoundError, RunRecordParseError, } from "../../domain/run/model/errors.js";
+import { fetchRunsSafely, rewriteRunRecord, RUN_RECORD_FILENAME, } from "../../domain/run/persistence/adapter.js";
+import { buildPruneAllConfirmationPreface, buildPruneConfirmationPreface, } from "../../render/transcripts/prune.js";
 import { toErrorMessage } from "../../utils/errors.js";
 import { pathExists } from "../../utils/fs.js";
 import { getGitStderr, runGitCommand } from "../../utils/git.js";
 import { normalizePathForDisplay, resolveDisplayPath, resolvePath, } from "../../utils/path.js";
 import { deriveAgentBranches, removeRunDirectory, removeWorkspaceEntry, } from "../../workspace/prune.js";
-import { buildAgentArtifactPaths, getAgentDirectoryPath, getAgentEvalsDirectoryPath, getAgentWorkspaceDirectoryPath, getRunDirectoryPath, resolveWorkspacePath, VORATIQ_RUNS_SESSIONS_DIR, } from "../../workspace/structure.js";
+import { buildAgentArtifactPaths, getAgentDirectoryPath, getAgentWorkspaceDirectoryPath, getRunDirectoryPath, resolveWorkspacePath, VORATIQ_RUN_SESSIONS_DIR, } from "../../workspace/structure.js";
 import { fetchRunSafely } from "../fetch.js";
 import { PruneBranchDeletionError, PruneRunDeletedError, RunMetadataMissingError, } from "./errors.js";
 export async function executePruneCommand(input) {
@@ -40,7 +40,6 @@ export async function executePruneCommand(input) {
         defaultValue: false,
         prefaceLines: buildPruneConfirmationPreface({
             runId: runRecord.runId,
-            specPath: runRecord.spec.path,
             workspaces: workspaceTargets.map((target) => target.displayPath),
             directories: agentDirectories,
             branches,
@@ -103,6 +102,52 @@ export async function executePruneCommand(input) {
         branches: branchSummary,
     };
 }
+export async function executePruneAllCommand(input) {
+    const { root, runsFilePath, confirm, clock, purge: purgeInput } = input;
+    const purge = purgeInput ?? false;
+    if (!confirm) {
+        throw new NonInteractiveShellError();
+    }
+    if (!(await pathExists(runsFilePath))) {
+        return { status: "noop", runIds: [] };
+    }
+    const { records, warnings } = await fetchRunsSafely({
+        root,
+        runsFilePath,
+    });
+    const firstWarning = warnings[0];
+    if (firstWarning) {
+        if (firstWarning.kind === "parse-error") {
+            throw new RunRecordParseError(firstWarning.displayPath, firstWarning.details);
+        }
+        throw new RunMetadataMissingError(firstWarning.runId);
+    }
+    if (records.length === 0) {
+        return { status: "noop", runIds: [] };
+    }
+    const eligibleRuns = sortRunRecordsByCreatedAt(records);
+    const runIds = eligibleRuns.map((record) => record.runId);
+    const confirmationAccepted = await confirm({
+        message: "Proceed?",
+        defaultValue: false,
+        prefaceLines: buildPruneAllConfirmationPreface({
+            records: eligibleRuns,
+        }),
+    });
+    if (!confirmationAccepted) {
+        return { status: "aborted", runIds };
+    }
+    for (const runId of runIds) {
+        await executePruneCommand({
+            ...input,
+            runId,
+            confirm: () => Promise.resolve(true),
+            purge,
+            clock,
+        });
+    }
+    return { status: "pruned", runIds };
+}
 function buildAgentDirectoryDisplayPaths(options) {
     const { runRecord } = options;
     const unique = new Set();
@@ -174,10 +219,6 @@ function buildArtifactTargets(options) {
         register(artifactPaths.diffPath, "file");
         register(artifactPaths.summaryPath, "file");
         register(artifactPaths.chatPath, "file");
-        const hasEvalLogs = (agent.evals ?? []).some((evaluation) => evaluation.hasLog);
-        if (hasEvalLogs) {
-            register(getAgentEvalsDirectoryPath(runRecord.runId, agent.agentId), "directory");
-        }
     }
     return Array.from(entries.values()).sort((a, b) => a.displayPath.localeCompare(b.displayPath));
 }
@@ -264,7 +305,7 @@ async function pruneArtifacts(options) {
 }
 async function purgeRunDirectoryExceptRecord(options) {
     const { root, runRecord } = options;
-    const runDir = resolveWorkspacePath(root, VORATIQ_RUNS_SESSIONS_DIR, runRecord.runId);
+    const runDir = resolveWorkspacePath(root, VORATIQ_RUN_SESSIONS_DIR, runRecord.runId);
     if (!(await pathExists(runDir))) {
         return;
     }
@@ -311,6 +352,16 @@ async function branchExists(root, branch) {
     });
     return output.length > 0;
 }
+function sortRunRecordsByCreatedAt(records) {
+    return Array.from(records).sort((a, b) => {
+        const aTimestamp = Date.parse(a.createdAt);
+        const bTimestamp = Date.parse(b.createdAt);
+        if (Number.isNaN(aTimestamp) || Number.isNaN(bTimestamp)) {
+            return a.createdAt.localeCompare(b.createdAt);
+        }
+        return aTimestamp - bTimestamp;
+    });
+}
 async function rewriteHistory(options) {
     const { root, runsFilePath, runId, deletedAt } = options;
     try {

package/dist/commands/prune/errors.d.ts

@@ -1,6 +1,6 @@
 import { CliError } from "../../cli/errors.js";
 export declare class PruneError extends CliError {
-    constructor(message: string);
+    constructor(headline: string, detailLines?: readonly string[], hintLines?: readonly string[]);
 }
 export declare class RunMetadataMissingError extends PruneError {
     readonly runId: string;

package/dist/commands/prune/errors.js

@@ -1,14 +1,14 @@
 import { CliError } from "../../cli/errors.js";
 export class PruneError extends CliError {
-    constructor(message) {
-        super(message);
+    constructor(headline, detailLines = [], hintLines = []) {
+        super(headline, detailLines, hintLines);
         this.name = "PruneError";
     }
 }
 export class RunMetadataMissingError extends PruneError {
     runId;
     constructor(runId) {
-        super(`Run metadata for ${runId} is missing from .voratiq/runs/sessions/${runId}/record.json; prune cannot proceed.`);
+        super(`Run metadata for \`${runId}\` is missing.`, [`Expected \`record.json\` under \`run/sessions/${runId}/\`.`], ["Re-run the spec to regenerate this run before pruning."]);
         this.runId = runId;
         this.name = "RunMetadataMissingError";
     }
@@ -17,7 +17,7 @@ export class PruneBranchDeletionError extends PruneError {
     branch;
     detail;
     constructor(branch, detail) {
-        super(`Failed to delete branch ${branch}: ${detail}`);
+        super(`Failed to delete branch \`${branch}\`.`, [detail], ["Delete the branch manually, then retry prune."]);
         this.branch = branch;
         this.detail = detail;
         this.name = "PruneBranchDeletionError";
@@ -26,7 +26,7 @@ export class PruneBranchDeletionError extends PruneError {
 export class PruneRunDeletedError extends PruneError {
     runId;
     constructor(runId) {
-        super(`Run ${runId} has been deleted.`);
+        super(`Run \`${runId}\` has been deleted.`, [], ["Select a different run to prune."]);
         this.runId = runId;
         this.name = "PruneRunDeletedError";
     }

package/dist/commands/prune/types.d.ts

@@ -9,6 +9,14 @@ export interface PruneCommandInput {
     purge?: boolean;
     clock?: () => Date;
 }
+export interface PruneAllCommandInput {
+    root: string;
+    runsDir: string;
+    runsFilePath: string;
+    confirm: PruneConfirmationHandler;
+    purge?: boolean;
+    clock?: () => Date;
+}
 export interface PruneBranchSummary {
     deleted: string[];
     skipped: string[];
@@ -40,3 +48,16 @@ export interface PruneAbortedResult {
     runPath: string;
 }
 export type PruneResult = PruneSuccessResult | PruneAbortedResult;
+export interface PruneAllSuccessResult {
+    status: "pruned";
+    runIds: string[];
+}
+export interface PruneAllNoopResult {
+    status: "noop";
+    runIds: string[];
+}
+export interface PruneAllAbortedResult {
+    status: "aborted";
+    runIds: string[];
+}
+export type PruneAllResult = PruneAllSuccessResult | PruneAllNoopResult | PruneAllAbortedResult;

package/dist/commands/reduce/command.d.ts

@@ -0,0 +1,26 @@
+import type { ResolvedExtraContextFile } from "../../competition/shared/extra-context.js";
+import { type ReductionCompetitionExecution } from "../../domain/reduce/competition/adapter.js";
+import type { ReductionTarget } from "../../domain/reduce/model/types.js";
+import type { ReduceProgressRenderer } from "../../render/transcripts/reduce.js";
+export interface ReduceCommandInput {
+    root: string;
+    specsFilePath: string;
+    runsFilePath: string;
+    reductionsFilePath: string;
+    messagesFilePath: string;
+    verificationsFilePath: string;
+    target: ReductionTarget;
+    agentIds?: readonly string[];
+    agentOverrideFlag?: string;
+    profileName?: string;
+    maxParallel?: number;
+    extraContextFiles?: readonly ResolvedExtraContextFile[];
+    renderer?: ReduceProgressRenderer;
+}
+export interface ReduceCommandResult {
+    reductionId: string;
+    target: ReductionTarget;
+    reducerAgentIds: readonly string[];
+    reductions: readonly ReductionCompetitionExecution[];
+}
+export declare function executeReduceCommand(input: ReduceCommandInput): Promise<ReduceCommandResult>;