voratiq 0.1.0-beta.20 → 0.1.0-beta.21

package/dist/contracts/list.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-export declare const listOperators: readonly ["spec", "run", "reduce", "verify"];
+export declare const listOperators: readonly ["spec", "run", "reduce", "verify", "message"];
 export declare const listModes: readonly ["table", "detail"];
 export type ListOperator = (typeof listOperators)[number];
 export type ListMode = (typeof listModes)[number];
@@ -21,7 +21,10 @@ export interface SpecListJsonTableRecord extends ListJsonRecordBase {
 export interface TargetedListJsonTableRecord extends ListJsonRecordBase {
     target: ListJsonTargetRef;
 }
-export type ListJsonTableRecord = RunListJsonTableRecord | SpecListJsonTableRecord | TargetedListJsonTableRecord;
+export interface MessageListJsonTableRecord extends ListJsonRecordBase {
+    promptPreview: string | null;
+}
+export type ListJsonTableRecord = RunListJsonTableRecord | SpecListJsonTableRecord | TargetedListJsonTableRecord | MessageListJsonTableRecord;
 export interface RunListJsonRow {
     agentId: string;
     status: string;
@@ -44,7 +47,12 @@ export interface VerifyListJsonRow {
     status: string;
     duration: string;
 }
-export type ListJsonRow = RunListJsonRow | SpecListJsonRow | ReduceListJsonRow | VerifyListJsonRow;
+export interface MessageListJsonRow {
+    agentId: string;
+    status: string;
+    duration: string;
+}
+export type ListJsonRow = RunListJsonRow | SpecListJsonRow | ReduceListJsonRow | VerifyListJsonRow | MessageListJsonRow;
 export interface SpecListJsonArtifact {
     kind: "spec";
     agentId: string;
@@ -61,7 +69,12 @@ export interface VerificationListJsonArtifact {
     verifier: string;
     path: string | null;
 }
-export type ListJsonArtifact = SpecListJsonArtifact | ReductionListJsonArtifact | VerificationListJsonArtifact;
+export interface MessageListJsonArtifact {
+    kind: "output";
+    agentId: string;
+    path: string | null;
+}
+export type ListJsonArtifact = SpecListJsonArtifact | ReductionListJsonArtifact | VerificationListJsonArtifact | MessageListJsonArtifact;
 export interface ListJsonTableOutput {
     operator: ListOperator;
     mode: "table";
@@ -78,6 +91,7 @@ export interface ListJsonDetailOutput {
         createdAt: string;
         elapsed?: string;
         workspacePath: string;
+        target?: ListJsonTargetRef;
         rows: ListJsonRow[];
         artifacts: ListJsonArtifact[];
     } | null;
@@ -85,6 +99,7 @@ export interface ListJsonDetailOutput {
 }
 export type ListJsonOutput = ListJsonTableOutput | ListJsonDetailOutput;
 export declare const listOperatorSchema: z.ZodEnum<{
+    message: "message";
     reduce: "reduce";
     spec: "spec";
     run: "run";
@@ -96,6 +111,7 @@ export declare const listModeSchema: z.ZodEnum<{
 }>;
 export declare const listJsonOutputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     operator: z.ZodEnum<{
+        message: "message";
         reduce: "reduce";
         spec: "spec";
         run: "run";
@@ -120,10 +136,16 @@ export declare const listJsonOutputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
             kind: z.ZodString;
             id: z.ZodString;
         }, z.core.$loose>;
+    }, z.core.$loose>, z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodString;
+        createdAt: z.ZodString;
+        promptPreview: z.ZodNullable<z.ZodString>;
     }, z.core.$loose>]>>;
     warnings: z.ZodArray<z.ZodString>;
 }, z.core.$loose>, z.ZodObject<{
     operator: z.ZodEnum<{
+        message: "message";
         reduce: "reduce";
         spec: "spec";
         run: "run";
@@ -137,6 +159,10 @@ export declare const listJsonOutputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
         createdAt: z.ZodString;
         elapsed: z.ZodOptional<z.ZodString>;
         workspacePath: z.ZodString;
+        target: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$loose>>;
         rows: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
             agentId: z.ZodString;
             status: z.ZodString;
@@ -151,6 +177,10 @@ export declare const listJsonOutputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
             verifier: z.ZodString;
             status: z.ZodString;
             duration: z.ZodString;
+        }, z.core.$loose>, z.ZodObject<{
+            agentId: z.ZodString;
+            status: z.ZodString;
+            duration: z.ZodString;
         }, z.core.$loose>]>>;
         artifacts: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
             kind: z.ZodLiteral<"spec">;
@@ -165,6 +195,10 @@ export declare const listJsonOutputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
             agentId: z.ZodNullable<z.ZodString>;
             verifier: z.ZodString;
             path: z.ZodNullable<z.ZodString>;
+        }, z.core.$loose>, z.ZodObject<{
+            kind: z.ZodLiteral<"output">;
+            agentId: z.ZodString;
+            path: z.ZodNullable<z.ZodString>;
         }, z.core.$loose>]>>;
     }, z.core.$loose>>;
     warnings: z.ZodArray<z.ZodString>;

package/dist/contracts/list.js

@@ -1,5 +1,11 @@
 import { z } from "zod";
-export const listOperators = ["spec", "run", "reduce", "verify"];
+export const listOperators = [
+    "spec",
+    "run",
+    "reduce",
+    "verify",
+    "message",
+];
 export const listModes = ["table", "detail"];
 export const listOperatorSchema = z.enum(listOperators);
 export const listModeSchema = z.enum(listModes);
@@ -31,6 +37,11 @@ const targetedListJsonTableRecordSchema = listJsonRecordBaseSchema
     target: listJsonTargetRefSchema,
 })
     .passthrough();
+const messageListJsonTableRecordSchema = listJsonRecordBaseSchema
+    .extend({
+    promptPreview: z.string().nullable(),
+})
+    .passthrough();
 const runListJsonRowSchema = z
     .object({
     agentId: z.string(),
@@ -54,6 +65,13 @@ const verifyListJsonRowSchema = z
     duration: z.string(),
 })
     .passthrough();
+const messageListJsonRowSchema = z
+    .object({
+    agentId: z.string(),
+    status: z.string(),
+    duration: z.string(),
+})
+    .passthrough();
 const specListJsonArtifactSchema = z
     .object({
     kind: z.literal("spec"),
@@ -76,6 +94,13 @@ const verificationListJsonArtifactSchema = z
     path: z.string().nullable(),
 })
     .passthrough();
+const messageListJsonArtifactSchema = z
+    .object({
+    kind: z.literal("output"),
+    agentId: z.string(),
+    path: z.string().nullable(),
+})
+    .passthrough();
 const listJsonDetailSessionSchema = z
     .object({
     id: z.string(),
@@ -83,15 +108,18 @@ const listJsonDetailSessionSchema = z
     createdAt: z.string(),
     elapsed: z.string().optional(),
     workspacePath: z.string(),
+    target: listJsonTargetRefSchema.optional(),
     rows: z.array(z.union([
         runListJsonRowSchema,
         stageListJsonRowSchema,
         verifyListJsonRowSchema,
+        messageListJsonRowSchema,
     ])),
     artifacts: z.array(z.union([
         specListJsonArtifactSchema,
         reductionListJsonArtifactSchema,
         verificationListJsonArtifactSchema,
+        messageListJsonArtifactSchema,
     ])),
 })
     .passthrough();
@@ -103,6 +131,7 @@ const listJsonTableOutputSchema = z
         runListJsonTableRecordSchema,
         specListJsonTableRecordSchema,
         targetedListJsonTableRecordSchema,
+        messageListJsonTableRecordSchema,
     ])),
     warnings: z.array(z.string()),
 })

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

@@ -0,0 +1,36 @@
+import type { CompetitionCommandAdapter } from "../../../competition/command-adapter.js";
+import { type ResolvedExtraContextFile } from "../../../competition/shared/extra-context.js";
+import { type TeardownController } from "../../../competition/shared/teardown.js";
+import type { AgentDefinition } from "../../../configs/agents/types.js";
+import type { EnvironmentConfig } from "../../../configs/environment/types.js";
+import type { TokenUsageResult } from "../../../workspace/chat/token-usage-result.js";
+import { type AgentWorkspacePaths } from "../../../workspace/layout.js";
+import type { ExtractedTokenUsage } from "../../run/model/types.js";
+export type MessageCompetitionCandidate = AgentDefinition;
+export interface MessageCompetitionExecution {
+    readonly agentId: string;
+    readonly status: "succeeded" | "failed";
+    readonly startedAt: string;
+    readonly completedAt: string;
+    readonly outputPath?: string;
+    readonly stdoutPath: string;
+    readonly stderrPath: string;
+    readonly tokenUsage?: ExtractedTokenUsage;
+    readonly tokenUsageResult: TokenUsageResult;
+    readonly error?: string;
+}
+interface PreparedMessageCompetitionCandidate {
+    readonly candidate: MessageCompetitionCandidate;
+    readonly workspacePaths: AgentWorkspacePaths;
+    readonly prompt: string;
+}
+export interface CreateMessageCompetitionAdapterInput {
+    readonly root: string;
+    readonly messageId: string;
+    readonly prompt: string;
+    readonly environment: EnvironmentConfig;
+    readonly extraContextFiles?: readonly ResolvedExtraContextFile[];
+    readonly teardown?: TeardownController;
+}
+export declare function createMessageCompetitionAdapter(input: CreateMessageCompetitionAdapterInput): CompetitionCommandAdapter<MessageCompetitionCandidate, PreparedMessageCompetitionCandidate, MessageCompetitionExecution>;
+export {};

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

@@ -0,0 +1,197 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { detectAgentProcessFailureDetail } from "../../../agents/runtime/failures.js";
+import { runSandboxedAgent } from "../../../agents/runtime/harness.js";
+import { teardownSessionAuth } from "../../../agents/runtime/registry.js";
+import { stageExtraContextFiles, } from "../../../competition/shared/extra-context.js";
+import { composeStageSandboxPolicy } from "../../../competition/shared/sandbox-policy.js";
+import { createTeardownController, runTeardown, } from "../../../competition/shared/teardown.js";
+import { buildUnavailableTokenUsageResult, resolveTokenUsage, } from "../../../domain/shared/token-usage.js";
+import { toErrorMessage } from "../../../utils/errors.js";
+import { normalizePathForDisplay, relativeToRoot, resolvePath, } from "../../../utils/path.js";
+import { extractProviderNativeTokenUsageForSession } from "../../../workspace/chat/native-usage.js";
+import { scaffoldAgentSessionWorkspace, } from "../../../workspace/layout.js";
+import { promoteWorkspaceFile } from "../../../workspace/promotion.js";
+import { MESSAGE_RESPONSE_FILENAME, VORATIQ_MESSAGE_DIR, } from "../../../workspace/structure.js";
+import { buildMessagePrompt } from "./prompt.js";
+export function createMessageCompetitionAdapter(input) {
+    const { root, messageId, prompt, environment, extraContextFiles = [], teardown: providedTeardown, } = input;
+    const teardown = providedTeardown ?? createTeardownController(`message \`${messageId}\``);
+    const ownsTeardown = providedTeardown === undefined;
+    teardown.addAction({
+        key: `message-auth:${messageId}`,
+        label: "session auth",
+        cleanup: async () => {
+            await teardownSessionAuth(messageId);
+        },
+    });
+    return {
+        failurePolicy: "continue",
+        prepareCandidates: async (candidates) => {
+            const ready = [];
+            const failures = [];
+            for (const candidate of candidates) {
+                const startedAt = new Date().toISOString();
+                try {
+                    const workspacePaths = await scaffoldAgentSessionWorkspace({
+                        root,
+                        domain: VORATIQ_MESSAGE_DIR,
+                        sessionId: messageId,
+                        agentId: candidate.id,
+                    });
+                    registerScratchWorkspaceTeardown(teardown, workspacePaths, candidate.id);
+                    await stageExtraContextFiles({
+                        contextPath: workspacePaths.contextPath,
+                        files: extraContextFiles,
+                    });
+                    const builtPrompt = buildMessagePrompt({
+                        prompt,
+                        repoRootPath: root,
+                        workspacePath: workspacePaths.workspacePath,
+                        extraContextFiles,
+                    });
+                    ready.push({
+                        candidate,
+                        workspacePaths,
+                        prompt: builtPrompt,
+                    });
+                }
+                catch (error) {
+                    const completedAt = new Date().toISOString();
+                    failures.push({
+                        agentId: candidate.id,
+                        status: "failed",
+                        startedAt,
+                        completedAt,
+                        stdoutPath: buildStdoutDisplayPath(root, messageId, candidate.id),
+                        stderrPath: buildStderrDisplayPath(root, messageId, candidate.id),
+                        tokenUsageResult: buildUnavailableTokenUsageResult({
+                            provider: candidate.provider,
+                            modelId: candidate.model,
+                            message: toErrorMessage(error),
+                        }),
+                        error: toErrorMessage(error),
+                    });
+                }
+            }
+            return { ready, failures };
+        },
+        executeCandidate: async (prepared) => {
+            const { candidate, workspacePaths, prompt: builtPrompt } = prepared;
+            const startedAt = new Date().toISOString();
+            try {
+                const result = await runSandboxedAgent({
+                    root,
+                    sessionId: messageId,
+                    sandboxStageId: "message",
+                    agent: candidate,
+                    prompt: builtPrompt,
+                    environment,
+                    paths: {
+                        agentRoot: workspacePaths.agentRoot,
+                        workspacePath: workspacePaths.workspacePath,
+                        sandboxHomePath: workspacePaths.sandboxHomePath,
+                        runtimeManifestPath: workspacePaths.runtimeManifestPath,
+                        sandboxSettingsPath: workspacePaths.sandboxSettingsPath,
+                        runtimePath: workspacePaths.runtimePath,
+                        artifactsPath: workspacePaths.artifactsPath,
+                        stdoutPath: workspacePaths.stdoutPath,
+                        stderrPath: workspacePaths.stderrPath,
+                    },
+                    captureChat: true,
+                    teardownAuthOnExit: false,
+                    ...composeStageSandboxPolicy(),
+                });
+                const tokenUsageResult = await extractProviderNativeTokenUsageForSession({
+                    root,
+                    domain: VORATIQ_MESSAGE_DIR,
+                    sessionId: messageId,
+                    agentId: candidate.id,
+                    provider: candidate.provider,
+                    modelId: candidate.model,
+                    chatCaptured: result.chat?.captured === true,
+                    format: result.chat?.format,
+                    artifactPath: result.chat?.artifactPath,
+                });
+                const tokenUsage = resolveTokenUsage(tokenUsageResult);
+                if (result.exitCode !== 0 || result.errorMessage) {
+                    const detail = (await detectAgentProcessFailureDetail({
+                        provider: candidate.provider,
+                        stdoutPath: workspacePaths.stdoutPath,
+                        stderrPath: workspacePaths.stderrPath,
+                    })) ??
+                        result.errorMessage ??
+                        `Agent exited with code ${result.exitCode ?? "unknown"}`;
+                    return {
+                        agentId: candidate.id,
+                        status: "failed",
+                        startedAt,
+                        completedAt: new Date().toISOString(),
+                        stdoutPath: normalizePathForDisplay(relativeToRoot(root, workspacePaths.stdoutPath)),
+                        stderrPath: normalizePathForDisplay(relativeToRoot(root, workspacePaths.stderrPath)),
+                        tokenUsage,
+                        tokenUsageResult,
+                        error: detail,
+                    };
+                }
+                const stagedResponsePath = join(workspacePaths.workspacePath, MESSAGE_RESPONSE_FILENAME);
+                await readFile(stagedResponsePath, "utf8");
+                const responsePromoteResult = await promoteWorkspaceFile({
+                    workspacePath: workspacePaths.workspacePath,
+                    artifactsPath: workspacePaths.artifactsPath,
+                    stagedRelativePath: MESSAGE_RESPONSE_FILENAME,
+                    artifactRelativePath: MESSAGE_RESPONSE_FILENAME,
+                    deleteStaged: true,
+                });
+                return {
+                    agentId: candidate.id,
+                    status: "succeeded",
+                    startedAt,
+                    completedAt: new Date().toISOString(),
+                    outputPath: normalizePathForDisplay(relativeToRoot(root, responsePromoteResult.artifactPath)),
+                    stdoutPath: normalizePathForDisplay(relativeToRoot(root, workspacePaths.stdoutPath)),
+                    stderrPath: normalizePathForDisplay(relativeToRoot(root, workspacePaths.stderrPath)),
+                    tokenUsage,
+                    tokenUsageResult,
+                };
+            }
+            catch (error) {
+                return {
+                    agentId: candidate.id,
+                    status: "failed",
+                    startedAt,
+                    completedAt: new Date().toISOString(),
+                    stdoutPath: normalizePathForDisplay(relativeToRoot(root, workspacePaths.stdoutPath)),
+                    stderrPath: normalizePathForDisplay(relativeToRoot(root, workspacePaths.stderrPath)),
+                    tokenUsageResult: buildUnavailableTokenUsageResult({
+                        provider: candidate.provider,
+                        modelId: candidate.model,
+                        message: toErrorMessage(error),
+                    }),
+                    error: toErrorMessage(error),
+                };
+            }
+        },
+        finalizeCompetition: async () => {
+            if (ownsTeardown) {
+                await runTeardown(teardown);
+            }
+        },
+        sortResults: compareMessageExecutionsByAgentId,
+    };
+}
+function registerScratchWorkspaceTeardown(teardown, workspacePaths, agentId) {
+    teardown.addPath(workspacePaths.workspacePath, `${agentId} workspace`);
+    teardown.addPath(workspacePaths.contextPath, `${agentId} context`);
+    teardown.addPath(workspacePaths.runtimePath, `${agentId} runtime`);
+    teardown.addPath(workspacePaths.sandboxPath, `${agentId} sandbox`);
+}
+function compareMessageExecutionsByAgentId(left, right) {
+    return left.agentId.localeCompare(right.agentId);
+}
+function buildStdoutDisplayPath(root, messageId, agentId) {
+    return normalizePathForDisplay(relativeToRoot(root, resolvePath(root, `.voratiq/message/sessions/${messageId}/${agentId}/artifacts/stdout.log`)));
+}
+function buildStderrDisplayPath(root, messageId, agentId) {
+    return normalizePathForDisplay(relativeToRoot(root, resolvePath(root, `.voratiq/message/sessions/${messageId}/${agentId}/artifacts/stderr.log`)));
+}

package/dist/domain/message/competition/prompt.d.ts

@@ -0,0 +1,8 @@
+import { type ResolvedExtraContextFile } from "../../../competition/shared/extra-context.js";
+export interface BuildMessagePromptOptions {
+    prompt: string;
+    repoRootPath: string;
+    workspacePath: string;
+    extraContextFiles?: readonly ResolvedExtraContextFile[];
+}
+export declare function buildMessagePrompt(options: BuildMessagePromptOptions): string;

package/dist/domain/message/competition/prompt.js

@@ -0,0 +1,29 @@
+import { appendExtraContextPromptSection, } from "../../../competition/shared/extra-context.js";
+import { appendConstraints, appendOutputRequirements, buildWorkspaceArtifactRequirements, } from "../../../competition/shared/prompt-helpers.js";
+export function buildMessagePrompt(options) {
+    const { prompt, repoRootPath, workspacePath, extraContextFiles = [], } = options;
+    const lines = [
+        "Respond to the prompt below using the available repository context.",
+        "",
+        "Guidance:",
+        "- Inspect the repository directly when needed.",
+        "- Keep the response focused on the prompt.",
+        "",
+        "Prompt:",
+        "```",
+        prompt.trim(),
+        "```",
+    ];
+    appendConstraints(lines, {
+        readAccess: repoRootPath,
+        writeAccess: workspacePath,
+    });
+    appendExtraContextPromptSection(lines, extraContextFiles);
+    appendOutputRequirements(lines, buildWorkspaceArtifactRequirements([
+        {
+            instruction: "Write the response",
+            path: "response.md",
+        },
+    ], ["- `response.md` is required."]));
+    return `${lines.join("\n")}\n`;
+}

package/dist/domain/message/model/mutators.d.ts

@@ -0,0 +1,17 @@
+import type { MessageRecipientEntry, MessageRecord, MessageStatus } from "./types.js";
+export interface MessageRecordMutators {
+    recordRecipientQueued: (recipient: MessageRecipientEntry) => Promise<void>;
+    recordRecipientRunning: (recipient: MessageRecipientEntry) => Promise<void>;
+    recordRecipientSnapshot: (recipient: MessageRecipientEntry) => Promise<void>;
+    completeMessage: (options: {
+        status: MessageStatus;
+        error?: string | null;
+    }) => Promise<MessageRecord>;
+    readRecord: () => Promise<MessageRecord | undefined>;
+}
+export interface CreateMessageRecordMutatorsInput {
+    readonly root: string;
+    readonly messagesFilePath: string;
+    readonly messageId: string;
+}
+export declare function createMessageRecordMutators(input: CreateMessageRecordMutatorsInput): MessageRecordMutators;

package/dist/domain/message/model/mutators.js

@@ -0,0 +1,107 @@
+import { buildLifecycleStartFields, buildRecordLifecycleCompleteFields, } from "../../shared/lifecycle.js";
+import { rewriteMessageRecord } from "../persistence/adapter.js";
+export function createMessageRecordMutators(input) {
+    const { root, messagesFilePath, messageId } = input;
+    return {
+        recordRecipientQueued: async (recipient) => {
+            await updateRecipient({
+                root,
+                messagesFilePath,
+                messageId,
+                recipient,
+            });
+        },
+        recordRecipientRunning: async (recipient) => {
+            await updateRecipient({
+                root,
+                messagesFilePath,
+                messageId,
+                recipient,
+            });
+        },
+        recordRecipientSnapshot: async (recipient) => {
+            await updateRecipient({
+                root,
+                messagesFilePath,
+                messageId,
+                recipient,
+                forceFlush: recipient.status === "succeeded" ||
+                    recipient.status === "failed" ||
+                    recipient.status === "aborted",
+            });
+        },
+        completeMessage: async ({ status, error }) => await rewriteMessageRecord({
+            root,
+            messagesFilePath,
+            sessionId: messageId,
+            mutate: (existing) => ({
+                ...existing,
+                status,
+                ...buildRecordLifecycleCompleteFields({ existing }),
+                ...(error !== undefined ? { error } : {}),
+            }),
+            forceFlush: true,
+        }),
+        readRecord: async () => await rewriteMessageRecord({
+            root,
+            messagesFilePath,
+            sessionId: messageId,
+            mutate: (record) => record,
+        }),
+    };
+}
+async function updateRecipient(options) {
+    const { root, messagesFilePath, messageId, recipient, forceFlush = false, } = options;
+    await rewriteMessageRecord({
+        root,
+        messagesFilePath,
+        sessionId: messageId,
+        forceFlush,
+        mutate: (existing) => {
+            const recipients = [...existing.recipients];
+            const index = recipients.findIndex((entry) => entry.agentId === recipient.agentId);
+            const current = index >= 0 ? recipients[index] : undefined;
+            const merged = mergeRecipientEntries(current, recipient);
+            if (index >= 0) {
+                recipients[index] = merged;
+            }
+            else {
+                recipients.push(merged);
+            }
+            return {
+                ...existing,
+                status: existing.status === "running" || merged.status !== "running"
+                    ? existing.status
+                    : "running",
+                ...(merged.startedAt
+                    ? buildLifecycleStartFields({
+                        existingStartedAt: existing.startedAt,
+                        timestamp: merged.startedAt,
+                    })
+                    : {}),
+                recipients,
+            };
+        },
+    });
+}
+function mergeRecipientEntries(existing, incoming) {
+    if (existing &&
+        isTerminalRecipientStatus(existing.status) &&
+        !isTerminalRecipientStatus(incoming.status)) {
+        return existing;
+    }
+    return {
+        ...(existing ?? {}),
+        ...incoming,
+        outputPath: incoming.outputPath ?? existing?.outputPath,
+        stdoutPath: incoming.stdoutPath ?? existing?.stdoutPath,
+        stderrPath: incoming.stderrPath ?? existing?.stderrPath,
+        tokenUsage: incoming.tokenUsage ?? existing?.tokenUsage,
+        error: incoming.error !== undefined ? incoming.error : (existing?.error ?? null),
+        startedAt: incoming.startedAt ?? existing?.startedAt,
+        completedAt: incoming.completedAt ?? existing?.completedAt,
+    };
+}
+function isTerminalRecipientStatus(status) {
+    return status === "succeeded" || status === "failed" || status === "aborted";
+}