patchrelay 0.1.0

package/dist/service-stage-finalizer.js

@@ -0,0 +1,348 @@
+import { ReconciliationActionApplier } from "./reconciliation-action-applier.js";
+import { reconcileIssue } from "./reconciliation-engine.js";
+import { buildReconciliationSnapshot } from "./reconciliation-snapshot-builder.js";
+import { syncFailedStageToLinear } from "./stage-failure.js";
+import { buildFailedStageReport, buildPendingMaterializationThread, buildStageReport, countEventMethods, extractStageSummary, extractTurnId, resolveStageRunStatus, summarizeCurrentThread, } from "./stage-reporting.js";
+import { StageLifecyclePublisher } from "./stage-lifecycle-publisher.js";
+import { StageTurnInputDispatcher } from "./stage-turn-input-dispatcher.js";
+import { safeJsonParse } from "./utils.js";
+export class ServiceStageFinalizer {
+    config;
+    stores;
+    codex;
+    linearProvider;
+    enqueueIssue;
+    inputDispatcher;
+    lifecyclePublisher;
+    actionApplier;
+    runAtomically;
+    constructor(config, stores, codex, linearProvider, enqueueIssue, logger, runAtomically = (fn) => fn()) {
+        this.config = config;
+        this.stores = stores;
+        this.codex = codex;
+        this.linearProvider = linearProvider;
+        this.enqueueIssue = enqueueIssue;
+        this.runAtomically = runAtomically;
+        const lifecycleLogger = logger ?? consoleLogger();
+        this.inputDispatcher = new StageTurnInputDispatcher(stores, codex, lifecycleLogger);
+        this.lifecyclePublisher = new StageLifecyclePublisher(config, stores, linearProvider, lifecycleLogger);
+        this.actionApplier = new ReconciliationActionApplier({
+            enqueueIssue,
+            deliverPendingObligations: (projectId, linearIssueId, threadId, turnId) => this.deliverPendingObligations(projectId, linearIssueId, threadId, turnId),
+            completeRun: (projectId, linearIssueId, thread, params) => this.completeReconciledRun(projectId, linearIssueId, thread, params),
+            failRunDuringReconciliation: (projectId, linearIssueId, threadId, message, options) => this.failRunLeaseDuringReconciliation(projectId, linearIssueId, threadId, message, options),
+        });
+    }
+    async getActiveStageStatus(issueKey) {
+        const issue = this.stores.issueWorkflows.getTrackedIssueByKey(issueKey);
+        if (!issue) {
+            return undefined;
+        }
+        const stageRun = this.resolveActiveStageRun(issue);
+        if (!stageRun?.threadId) {
+            return undefined;
+        }
+        const thread = await this.codex.readThread(stageRun.threadId, true).catch((error) => {
+            const err = error instanceof Error ? error : new Error(String(error));
+            return buildPendingMaterializationThread(stageRun, err);
+        });
+        return {
+            issue,
+            stageRun,
+            liveThread: summarizeCurrentThread(thread),
+        };
+    }
+    async handleCodexNotification(notification) {
+        const threadId = typeof notification.params.threadId === "string" ? notification.params.threadId : undefined;
+        if (!threadId) {
+            return;
+        }
+        const stageRun = this.stores.issueWorkflows.getStageRunByThreadId(threadId);
+        if (!stageRun) {
+            return;
+        }
+        const turnId = typeof notification.params.turnId === "string" ? notification.params.turnId : undefined;
+        if (this.config.runner.codex.persistExtendedHistory) {
+            this.stores.stageEvents.saveThreadEvent({
+                stageRunId: stageRun.id,
+                threadId,
+                ...(turnId ? { turnId } : {}),
+                method: notification.method,
+                eventJson: JSON.stringify(notification.params),
+            });
+        }
+        if (notification.method === "turn/started" || notification.method.startsWith("item/")) {
+            await this.flushQueuedTurnInputs(stageRun);
+        }
+        if (notification.method !== "turn/completed") {
+            return;
+        }
+        const thread = await this.codex.readThread(threadId, true);
+        const issue = this.stores.issueWorkflows.getTrackedIssue(stageRun.projectId, stageRun.linearIssueId);
+        if (!issue) {
+            return;
+        }
+        const completedTurnId = extractTurnId(notification.params);
+        const status = resolveStageRunStatus(notification.params);
+        if (status === "failed") {
+            await this.failStageRunAndSync(stageRun, issue, threadId, "Codex reported the turn completed in a failed state", {
+                ...(completedTurnId ? { turnId: completedTurnId } : {}),
+            });
+            return;
+        }
+        this.completeStageRun(stageRun, issue, thread, status, {
+            threadId,
+            ...(completedTurnId ? { turnId: completedTurnId } : {}),
+        });
+    }
+    async reconcileActiveStageRuns() {
+        for (const runLeaseId of this.stores.runLeases.listActiveRunLeases().filter((runLease) => runLease.status === "running").map((runLease) => runLease.id)) {
+            await this.reconcileRunLease(runLeaseId);
+        }
+    }
+    completeStageRun(stageRun, issue, thread, status, params) {
+        const refreshedStageRun = this.stores.issueWorkflows.getStageRun(stageRun.id) ?? stageRun;
+        const finalizedStageRun = {
+            ...refreshedStageRun,
+            status,
+            threadId: params.threadId,
+            ...(params.turnId ? { turnId: params.turnId } : {}),
+        };
+        const report = buildStageReport(finalizedStageRun, issue, thread, countEventMethods(this.stores.stageEvents.listThreadEvents(stageRun.id)));
+        this.runAtomically(() => {
+            this.finishLedgerRun(stageRun.projectId, stageRun.linearIssueId, "completed", {
+                threadId: params.threadId,
+                ...(params.turnId ? { turnId: params.turnId } : {}),
+                nextLifecycleStatus: params.nextLifecycleStatus ?? (issue.desiredStage ? "queued" : "completed"),
+            });
+            this.stores.issueWorkflows.finishStageRun({
+                stageRunId: stageRun.id,
+                status,
+                threadId: params.threadId,
+                ...(params.turnId ? { turnId: params.turnId } : {}),
+                summaryJson: JSON.stringify(extractStageSummary(report)),
+                reportJson: JSON.stringify(report),
+            });
+        });
+        void this.advanceAfterStageCompletion(stageRun);
+    }
+    failStageRun(stageRun, threadId, message, options) {
+        this.runAtomically(() => {
+            this.finishLedgerRun(stageRun.projectId, stageRun.linearIssueId, "failed", {
+                threadId,
+                ...(options?.turnId ? { turnId: options.turnId } : {}),
+                failureReason: message,
+                nextLifecycleStatus: "failed",
+            });
+            this.stores.issueWorkflows.finishStageRun({
+                stageRunId: stageRun.id,
+                status: "failed",
+                threadId,
+                ...(options?.turnId ? { turnId: options.turnId } : {}),
+                summaryJson: JSON.stringify({ message }),
+                reportJson: JSON.stringify(buildFailedStageReport(stageRun, "failed", {
+                    threadId,
+                    ...(options?.turnId ? { turnId: options.turnId } : {}),
+                })),
+            });
+        });
+    }
+    async failStageRunDuringReconciliation(stageRun, threadId, message, options) {
+        this.failStageRun(stageRun, threadId, message, options);
+        const issue = this.stores.issueWorkflows.getTrackedIssue(stageRun.projectId, stageRun.linearIssueId);
+        const project = this.config.projects.find((candidate) => candidate.id === stageRun.projectId);
+        if (!issue || !project) {
+            return;
+        }
+        await syncFailedStageToLinear({
+            stores: this.stores,
+            linearProvider: this.linearProvider,
+            project,
+            issue,
+            stageRun: {
+                ...stageRun,
+                threadId,
+                ...(options?.turnId ? { turnId: options.turnId } : {}),
+            },
+            message,
+            mode: "failed",
+            requireActiveLinearStateMatch: true,
+        });
+    }
+    async failStageRunAndSync(stageRun, issue, threadId, message, options) {
+        this.failStageRun(stageRun, threadId, message, options);
+        const project = this.config.projects.find((candidate) => candidate.id === stageRun.projectId);
+        if (!project) {
+            return;
+        }
+        await syncFailedStageToLinear({
+            stores: this.stores,
+            linearProvider: this.linearProvider,
+            project,
+            issue,
+            stageRun: {
+                ...stageRun,
+                threadId,
+                ...(options?.turnId ? { turnId: options.turnId } : {}),
+            },
+            message,
+            mode: "failed",
+        });
+    }
+    async flushQueuedTurnInputs(stageRun) {
+        await this.inputDispatcher.flush(stageRun);
+    }
+    async advanceAfterStageCompletion(stageRun) {
+        await this.lifecyclePublisher.publishStageCompletion(stageRun, this.enqueueIssue);
+    }
+    finishLedgerRun(projectId, linearIssueId, status, params) {
+        const issueControl = this.stores.issueControl.getIssueControl(projectId, linearIssueId);
+        if (!issueControl?.activeRunLeaseId) {
+            return;
+        }
+        this.stores.runLeases.finishRunLease({
+            runLeaseId: issueControl.activeRunLeaseId,
+            status,
+            ...(params.threadId ? { threadId: params.threadId } : {}),
+            ...(params.turnId ? { turnId: params.turnId } : {}),
+            ...(params.failureReason ? { failureReason: params.failureReason } : {}),
+        });
+        if (issueControl.activeWorkspaceOwnershipId !== undefined) {
+            const workspace = this.stores.workspaceOwnership.getWorkspaceOwnership(issueControl.activeWorkspaceOwnershipId);
+            if (workspace) {
+                this.stores.workspaceOwnership.upsertWorkspaceOwnership({
+                    projectId,
+                    linearIssueId,
+                    branchName: workspace.branchName,
+                    worktreePath: workspace.worktreePath,
+                    status: status === "completed" ? "active" : "paused",
+                    currentRunLeaseId: null,
+                });
+            }
+        }
+        this.stores.issueControl.upsertIssueControl({
+            projectId,
+            linearIssueId,
+            activeRunLeaseId: null,
+            ...(issueControl.activeWorkspaceOwnershipId !== undefined
+                ? { activeWorkspaceOwnershipId: issueControl.activeWorkspaceOwnershipId }
+                : {}),
+            ...(issueControl.serviceOwnedCommentId ? { serviceOwnedCommentId: issueControl.serviceOwnedCommentId } : {}),
+            ...(issueControl.activeAgentSessionId ? { activeAgentSessionId: issueControl.activeAgentSessionId } : {}),
+            lifecycleStatus: params.nextLifecycleStatus,
+        });
+    }
+    async deliverPendingObligations(projectId, linearIssueId, threadId, turnId) {
+        if (!turnId) {
+            return;
+        }
+        await this.inputDispatcher.flush({
+            id: 0,
+            projectId,
+            linearIssueId,
+            threadId,
+            turnId,
+        }, {
+            retryInProgress: true,
+        });
+    }
+    async reconcileRunLease(runLeaseId) {
+        const snapshot = await buildReconciliationSnapshot({
+            config: this.config,
+            stores: {
+                issueControl: this.stores.issueControl,
+                runLeases: this.stores.runLeases,
+                workspaceOwnership: this.stores.workspaceOwnership,
+                obligations: this.stores.obligations,
+            },
+            codex: this.codex,
+            linearProvider: this.linearProvider,
+            runLeaseId,
+        });
+        if (!snapshot) {
+            return;
+        }
+        const decision = reconcileIssue(snapshot.input);
+        if (decision.outcome === "hydrate_live_state") {
+            throw new Error(`Startup reconciliation requires live state hydration for ${snapshot.runLease.projectId}:${snapshot.runLease.linearIssueId}: ${decision.reasons.join("; ")}`);
+        }
+        await this.actionApplier.apply({
+            snapshot,
+            decision,
+        });
+    }
+    completeReconciledRun(projectId, linearIssueId, thread, params) {
+        const stageRun = this.findStageRunForIssue(projectId, linearIssueId, params.threadId);
+        const issue = this.stores.issueWorkflows.getTrackedIssue(projectId, linearIssueId);
+        if (!stageRun || !issue) {
+            this.finishLedgerRun(projectId, linearIssueId, "completed", {
+                threadId: params.threadId,
+                ...(params.turnId ? { turnId: params.turnId } : {}),
+                nextLifecycleStatus: params.nextLifecycleStatus ?? "completed",
+            });
+            return;
+        }
+        this.completeStageRun(stageRun, issue, thread, "completed", params);
+    }
+    async failRunLeaseDuringReconciliation(projectId, linearIssueId, threadId, message, options) {
+        const stageRun = this.findStageRunForIssue(projectId, linearIssueId, threadId);
+        if (!stageRun) {
+            this.finishLedgerRun(projectId, linearIssueId, "failed", {
+                threadId,
+                ...(options?.turnId ? { turnId: options.turnId } : {}),
+                failureReason: message,
+                nextLifecycleStatus: "failed",
+            });
+            return;
+        }
+        await this.failStageRunDuringReconciliation(stageRun, threadId, message, options);
+    }
+    findStageRunForIssue(projectId, linearIssueId, threadId) {
+        return (threadId ? this.stores.issueWorkflows.getStageRunByThreadId(threadId) : undefined) ??
+            this.stores.issueWorkflows.getLatestStageRunForIssue(projectId, linearIssueId);
+    }
+    resolveActiveStageRun(issue) {
+        const issueControl = this.stores.issueControl.getIssueControl(issue.projectId, issue.linearIssueId);
+        if (issueControl?.activeRunLeaseId !== undefined) {
+            const directStageRun = this.stores.issueWorkflows.getStageRun(issueControl.activeRunLeaseId);
+            if (directStageRun) {
+                return directStageRun;
+            }
+            const runLease = this.stores.runLeases.getRunLease(issueControl.activeRunLeaseId);
+            if (runLease) {
+                return {
+                    id: runLease.id,
+                    pipelineRunId: runLease.id,
+                    projectId: runLease.projectId,
+                    linearIssueId: runLease.linearIssueId,
+                    workspaceId: runLease.workspaceOwnershipId,
+                    stage: runLease.stage,
+                    status: runLease.status === "failed" ? "failed" : runLease.status === "completed" || runLease.status === "released" ? "completed" : "running",
+                    triggerWebhookId: "ledger-trigger",
+                    workflowFile: runLease.workflowFile,
+                    promptText: runLease.promptText,
+                    ...(runLease.threadId ? { threadId: runLease.threadId } : {}),
+                    ...(runLease.parentThreadId ? { parentThreadId: runLease.parentThreadId } : {}),
+                    ...(runLease.turnId ? { turnId: runLease.turnId } : {}),
+                    startedAt: runLease.startedAt,
+                    ...(runLease.endedAt ? { endedAt: runLease.endedAt } : {}),
+                };
+            }
+        }
+        return undefined;
+    }
+}
+function consoleLogger() {
+    const noop = () => undefined;
+    return {
+        fatal: noop,
+        error: noop,
+        warn: noop,
+        info: noop,
+        debug: noop,
+        trace: noop,
+        silent: noop,
+        child: () => consoleLogger(),
+        level: "silent",
+    };
+}

package/dist/service-stage-runner.js

@@ -0,0 +1,233 @@
+import { buildStageLaunchPlan, isCodexThreadId } from "./stage-launch.js";
+import { syncFailedStageToLinear } from "./stage-failure.js";
+import { buildFailedStageReport } from "./stage-reporting.js";
+import { StageLifecyclePublisher } from "./stage-lifecycle-publisher.js";
+import { StageTurnInputDispatcher } from "./stage-turn-input-dispatcher.js";
+import { WorktreeManager } from "./worktree-manager.js";
+export class ServiceStageRunner {
+    config;
+    stores;
+    codex;
+    linearProvider;
+    logger;
+    worktreeManager;
+    inputDispatcher;
+    lifecyclePublisher;
+    runAtomically;
+    constructor(config, stores, codex, linearProvider, logger, runAtomically = (fn) => fn()) {
+        this.config = config;
+        this.stores = stores;
+        this.codex = codex;
+        this.linearProvider = linearProvider;
+        this.logger = logger;
+        this.runAtomically = runAtomically;
+        this.worktreeManager = new WorktreeManager(config);
+        this.inputDispatcher = new StageTurnInputDispatcher(stores, codex, logger);
+        this.lifecyclePublisher = new StageLifecyclePublisher(config, stores, linearProvider, logger);
+    }
+    async run(item) {
+        const project = this.config.projects.find((candidate) => candidate.id === item.projectId);
+        if (!project) {
+            return;
+        }
+        const issueControl = this.stores.issueControl.getIssueControl(item.projectId, item.issueId);
+        if (!issueControl?.desiredStage || issueControl.activeRunLeaseId !== undefined) {
+            return;
+        }
+        const receipt = issueControl.desiredReceiptId !== undefined ? this.stores.eventReceipts.getEventReceipt(issueControl.desiredReceiptId) : undefined;
+        if (!receipt?.externalId) {
+            return;
+        }
+        const desiredStage = issueControl.desiredStage;
+        const desiredWebhookId = receipt.externalId;
+        const issue = await this.ensureLaunchIssueMirror(project, item.issueId, desiredStage, desiredWebhookId);
+        if (!issue) {
+            return;
+        }
+        const plan = buildStageLaunchPlan(project, issue, desiredStage);
+        const claim = this.stores.issueWorkflows.claimStageRun({
+            projectId: item.projectId,
+            linearIssueId: item.issueId,
+            stage: desiredStage,
+            triggerWebhookId: desiredWebhookId,
+            branchName: plan.branchName,
+            worktreePath: plan.worktreePath,
+            workflowFile: plan.workflowFile,
+            promptText: plan.prompt,
+        });
+        if (!claim) {
+            return;
+        }
+        let threadLaunch;
+        let turn;
+        try {
+            await this.worktreeManager.ensureIssueWorktree(project.repoPath, project.worktreeRoot, plan.worktreePath, plan.branchName);
+            await this.lifecyclePublisher.markStageActive(project, claim.issue, claim.stageRun);
+            threadLaunch = await this.launchStageThread(item.projectId, item.issueId, claim.stageRun.id, plan.worktreePath, issue.issueKey);
+            turn = await this.codex.startTurn({
+                threadId: threadLaunch.threadId,
+                cwd: plan.worktreePath,
+                input: plan.prompt,
+            });
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            await this.markLaunchFailed(project, claim.issue, claim.stageRun, err.message, threadLaunch?.threadId);
+            this.logger.error({
+                issueKey: issue.issueKey,
+                stage: claim.stageRun.stage,
+                worktreePath: plan.worktreePath,
+                branchName: plan.branchName,
+                error: err.message,
+                stack: err.stack,
+            }, "Failed to launch Codex stage run");
+            throw err;
+        }
+        this.stores.issueWorkflows.updateStageRunThread({
+            stageRunId: claim.stageRun.id,
+            threadId: threadLaunch.threadId,
+            ...(threadLaunch.parentThreadId ? { parentThreadId: threadLaunch.parentThreadId } : {}),
+            turnId: turn.turnId,
+        });
+        this.inputDispatcher.routePendingInputs(claim.stageRun, threadLaunch.threadId, turn.turnId);
+        await this.inputDispatcher.flush({
+            id: claim.stageRun.id,
+            projectId: claim.stageRun.projectId,
+            linearIssueId: claim.stageRun.linearIssueId,
+            threadId: threadLaunch.threadId,
+            turnId: turn.turnId,
+        }, {
+            logFailures: true,
+            failureMessage: "Failed to deliver queued Linear comment during stage startup",
+            ...(claim.issue.issueKey ? { issueKey: claim.issue.issueKey } : {}),
+        });
+        await this.lifecyclePublisher.refreshRunningStatusComment(item.projectId, item.issueId, claim.stageRun.id, issue.issueKey);
+        await this.lifecyclePublisher.publishStageStarted(claim.issue, claim.stageRun.stage);
+        this.logger.info({
+            issueKey: issue.issueKey,
+            stage: claim.stageRun.stage,
+            worktreePath: plan.worktreePath,
+            branchName: plan.branchName,
+            threadId: threadLaunch.threadId,
+            turnId: turn.turnId,
+        }, "Started Codex stage run");
+    }
+    async ensureLaunchIssueMirror(project, linearIssueId, _desiredStage, _desiredWebhookId) {
+        const existing = this.stores.issueWorkflows.getTrackedIssue(project.id, linearIssueId);
+        if (existing?.issueKey && existing.title && existing.issueUrl && existing.currentLinearState) {
+            return existing;
+        }
+        const liveIssue = await this.linearProvider
+            .forProject(project.id)
+            .then((linear) => linear?.getIssue(linearIssueId))
+            .catch(() => undefined);
+        return this.stores.issueWorkflows.recordDesiredStage({
+            projectId: project.id,
+            linearIssueId,
+            ...(liveIssue?.identifier ? { issueKey: liveIssue.identifier } : existing?.issueKey ? { issueKey: existing.issueKey } : {}),
+            ...(liveIssue?.title ? { title: liveIssue.title } : existing?.title ? { title: existing.title } : {}),
+            ...(liveIssue?.url ? { issueUrl: liveIssue.url } : existing?.issueUrl ? { issueUrl: existing.issueUrl } : {}),
+            ...(liveIssue?.stateName
+                ? { currentLinearState: liveIssue.stateName }
+                : existing?.currentLinearState
+                    ? { currentLinearState: existing.currentLinearState }
+                    : {}),
+            lastWebhookAt: new Date().toISOString(),
+        });
+    }
+    async launchStageThread(projectId, issueId, stageRunId, worktreePath, issueKey) {
+        const previousStageRun = this.stores.issueWorkflows
+            .listStageRunsForIssue(projectId, issueId)
+            .filter((stageRun) => stageRun.id !== stageRunId)
+            .at(-1);
+        const parentThreadId = previousStageRun?.status === "completed" && isCodexThreadId(previousStageRun.threadId)
+            ? previousStageRun.threadId
+            : undefined;
+        if (parentThreadId) {
+            try {
+                const thread = await this.codex.forkThread(parentThreadId, worktreePath);
+                return {
+                    threadId: thread.id,
+                    parentThreadId,
+                };
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                this.logger.warn({
+                    issueKey,
+                    parentThreadId,
+                    error: err.message,
+                }, "Falling back to a fresh Codex thread after parent thread fork failed");
+            }
+        }
+        const thread = await this.codex.startThread({ cwd: worktreePath });
+        return {
+            threadId: thread.id,
+        };
+    }
+    async markLaunchFailed(project, issue, stageRun, message, threadId) {
+        const failureThreadId = threadId ?? `launch-failed-${stageRun.id}`;
+        this.runAtomically(() => {
+            this.stores.issueWorkflows.finishStageRun({
+                stageRunId: stageRun.id,
+                status: "failed",
+                threadId: failureThreadId,
+                summaryJson: JSON.stringify({ message }),
+                reportJson: JSON.stringify(buildFailedStageReport(stageRun, "failed", { threadId: failureThreadId })),
+            });
+            this.finishRunLease(stageRun.projectId, stageRun.linearIssueId, "failed", {
+                threadId: failureThreadId,
+                failureReason: message,
+            });
+        });
+        await syncFailedStageToLinear({
+            stores: this.stores,
+            linearProvider: this.linearProvider,
+            project,
+            issue,
+            stageRun: {
+                ...stageRun,
+                threadId: failureThreadId,
+            },
+            message,
+            mode: "launch",
+        });
+    }
+    finishRunLease(projectId, linearIssueId, status, params) {
+        const issueControl = this.stores.issueControl.getIssueControl(projectId, linearIssueId);
+        if (!issueControl?.activeRunLeaseId) {
+            return;
+        }
+        this.stores.runLeases.finishRunLease({
+            runLeaseId: issueControl.activeRunLeaseId,
+            status,
+            ...(params.threadId ? { threadId: params.threadId } : {}),
+            ...(params.turnId ? { turnId: params.turnId } : {}),
+            ...(params.failureReason ? { failureReason: params.failureReason } : {}),
+        });
+        if (issueControl.activeWorkspaceOwnershipId !== undefined) {
+            const workspace = this.stores.workspaceOwnership.getWorkspaceOwnership(issueControl.activeWorkspaceOwnershipId);
+            if (workspace) {
+                this.stores.workspaceOwnership.upsertWorkspaceOwnership({
+                    projectId,
+                    linearIssueId,
+                    branchName: workspace.branchName,
+                    worktreePath: workspace.worktreePath,
+                    status: "paused",
+                    currentRunLeaseId: null,
+                });
+            }
+        }
+        this.stores.issueControl.upsertIssueControl({
+            projectId,
+            linearIssueId,
+            activeRunLeaseId: null,
+            lifecycleStatus: "failed",
+            ...(issueControl.activeWorkspaceOwnershipId !== undefined
+                ? { activeWorkspaceOwnershipId: issueControl.activeWorkspaceOwnershipId }
+                : {}),
+            ...(issueControl.serviceOwnedCommentId ? { serviceOwnedCommentId: issueControl.serviceOwnedCommentId } : {}),
+            ...(issueControl.activeAgentSessionId ? { activeAgentSessionId: issueControl.activeAgentSessionId } : {}),
+        });
+    }
+}