@straiffi/archon 1.8.23 → 1.10.1

package/dist/server/workers/plan.js

@@ -7,8 +7,8 @@ import { GitHubApiError } from '../lib/integrations/github.js';
 import { formatGenericToolCall } from '../lib/genericToolCall.js';
 import { PlanningReferenceError, resolveExternalPlanningDescription } from '../lib/integrations/planning.js';
 import { resolveExistingWorktreePath } from '../lib/git.js';
-import { normalizeModelId } from '../lib/models.js';
-import { parseOpencodeTaskEnvelope } from '../lib/opencodeTaskSessions.js';
+import { getModelProvider, normalizeModelId } from '../lib/models.js';
+import { createOpencodeTaskSessionReader, parseOpencodeTaskEnvelope } from '../lib/opencodeTaskSessions.js';
 import { hostOpencodeSessionOperations } from '../lib/opencodeSessionOperations.js';
 import { markRetryableOpenCodeDatabaseLock, RetryableOpenCodeDatabaseLockError, retryOpenCodeDatabaseLocks } from '../lib/opencodeExecutionReliability.js';
 import { appendClaudeHeadlessPlanPrompt, appendPlanModeQuestionPromptRules, buildClaudeHeadlessPlanArgs } from '../lib/planModeQuestions.js';
@@ -25,9 +25,14 @@ import { createTicketMessage, upsertTicketDescriptionMessage } from '../lib/tick
 import { createAskQuestionMetadata, extractAskQuestionFromOutput, formatAskQuestionMessage } from '../lib/planQuestions.js';
 import { getTicket, resolveTicketBranch, resolveTicketTool, resolveTicketWorkerKey } from '../lib/tickets.js';
 import { createOpencodeSubagentMonitor, createSubagentRunTracker, formatAgentErrorForTranscript, getAgentErrorTranscriptRuns, readOpencodeSessionTranscript, storeTicketUsageSnapshot, storeTicketUsageSnapshotDirect, mergeUsageFromJsonLine, EMPTY_CHAT_USAGE_SNAPSHOT } from '../lib/agent.js';
-import { createAgentRun, emitAgentRunsUpdated, finalizeAgentRun, getNextAgentRunIndex, terminalizeAgentRunsForExecutionRun } from '../lib/agentRuns.js';
+import { createAgentRun, emitAgentRunsUpdated, finalizeAgentRun, getAgentRun, getNextAgentRunIndex, terminalizeAgentRunsForExecutionRun, updateAgentRunSessionId } from '../lib/agentRuns.js';
 import { addExecutionRunLink, createExecutionRun, transitionExecutionRun } from '../lib/executionRuns.js';
+import { assertProviderSessionAuthorityMatches, createExecutionProfileSelectionMetadata } from '../lib/executionRunAuthority.js';
+import { classifyTicketExecutionTarget, resolveExecutionTarget, resolveProjectRootExecutionTarget } from '../lib/executionTargets.js';
+import { resolveWorkloadExecutionEnvironment } from '../lib/workloadExecutionEnvironment.js';
 import { createWorkspaceProcessEnvironment } from '../lib/workspaceProcessEnvironment.js';
+import { createHostLauncherEnvironment, createLegacyHostRuntimeEnvironment } from '../lib/workspaceProcessEnvironment.js';
+import { hostExecutionEnvironment } from '../lib/hostExecutionEnvironment.js';
 const resolvePlannerAgentRunParent = (options) => {
     if (options.agentRunParent) {
         return options.agentRunParent;
@@ -37,6 +42,12 @@ const resolvePlannerAgentRunParent = (options) => {
     }
     return undefined;
 };
+const plannerExecutionOptions = (options) => ({
+    executionProvider: options.executionProvider,
+    executionTarget: options.executionTarget,
+    executionLauncherEnvironment: options.executionLauncherEnvironment,
+    executionRuntimeEnvironment: options.executionRuntimeEnvironment,
+});
 const createPlanningInvocation = (options, label, role) => {
     const parentType = options.agentRunParent?.parentType ?? (options.ticketId ? 'ticket' : options.projectId ? 'planning' : null);
     const parentId = options.agentRunParent?.parentId ?? options.ticketId ?? options.projectId ?? null;
@@ -939,13 +950,18 @@ const resolvePlannerCwd = (project, branch) => {
     }
     return resolveExistingWorktreePath(branch, project) ?? project.repo_path;
 };
-export const updatePlanningSessionId = (ticketId, sessionId, io) => {
+export const updatePlanningSessionId = (ticketId, sessionId, io, sessionOperations) => {
     const existing = getTicket(ticketId);
     const resolvedTool = resolveTicketTool(existing, config.tool ?? 'opencode');
     db.prepare('UPDATE tickets SET planning_session_id = ?, tool = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?').run(sessionId, resolvedTool, ticketId);
     const ticket = getTicket(ticketId);
     if (ticket && resolveTicketTool(ticket, config.tool ?? 'opencode') === 'opencode') {
-        void storeTicketUsageSnapshot(ticket.id, sessionId);
+        if (sessionOperations) {
+            void storeTicketUsageSnapshot(ticket.id, sessionId, sessionOperations);
+        }
+        else {
+            void storeTicketUsageSnapshot(ticket.id, sessionId);
+        }
     }
     const freshTicket = getTicket(ticketId) ?? ticket;
     if (freshTicket) {
@@ -996,15 +1012,15 @@ export const stopPlannerProcesses = async (children) => {
         killPlannerProcess(child, 'SIGKILL');
     }
 };
-const opencodeSessionHasCompletedAssistantSince = (sessionId, sinceMs) => {
-    return hostOpencodeSessionOperations.hasCompletedAssistantSince(sessionId, sinceMs);
-};
 const runPlannerPromptOnce = (tool, model, variant, prompt, cwd, options = {}) => {
     const resolvedModel = normalizeModelId(model);
     const finalPrompt = tool === 'claude'
         ? appendClaudeHeadlessPlanPrompt(prompt)
         : prompt;
     const sessionTracking = options.sessionTracking;
+    const opencodeSessionOperations = options.executionProvider
+        ? options.executionProvider.sessionOperations.opencode
+        : hostOpencodeSessionOperations;
     let sessionId = null;
     let spawnTimestamp = null;
     let sessionLookupTimer = null;
@@ -1090,26 +1106,29 @@ const runPlannerPromptOnce = (tool, model, variant, prompt, cwd, options = {}) =
                 watchdogTimer = null;
             }
         };
-        const bindResolvedOpencodeSession = (resolvedId) => {
+        const bindResolvedProviderSession = (resolvedId) => {
             const normalized = resolvedId?.trim();
             if (!normalized) {
                 return;
             }
             resolvedSessionId = normalized;
             opencodeSubagentMonitor?.setParentSessionId(normalized);
+            if (options.mainRun) {
+                updateAgentRunSessionId(options.mainRun.id, normalized);
+            }
             if (sessionTracking && !hasResolvedSessionId) {
                 hasResolvedSessionId = true;
-                updatePlanningSessionId(sessionTracking.ticketId, normalized, sessionTracking.io);
+                updatePlanningSessionId(sessionTracking.ticketId, normalized, sessionTracking.io, opencodeSessionOperations ?? undefined);
             }
         };
         const attemptOpencodeSessionLookup = async () => {
-            if (!sessionTracking || tool !== 'opencode' || hasResolvedSessionId) {
+            if (!sessionTracking || tool !== 'opencode' || hasResolvedSessionId || !opencodeSessionOperations) {
                 return false;
             }
             try {
-                const session = await hostOpencodeSessionOperations.findLatestSessionAfter(spawnTimestamp ?? 0, cwd);
+                const session = await opencodeSessionOperations.findLatestSessionAfter(spawnTimestamp ?? 0, cwd);
                 if (!hasResolvedSessionId && session?.id) {
-                    bindResolvedOpencodeSession(session.id);
+                    bindResolvedProviderSession(session.id);
                 }
             }
             catch {
@@ -1121,15 +1140,36 @@ const runPlannerPromptOnce = (tool, model, variant, prompt, cwd, options = {}) =
             spawnTimestamp = Date.now();
         }
         let child;
+        let placementFailure = Promise.resolve(null);
         try {
-            child = spawn(cmd, args, {
-                stdio: ['ignore', 'pipe', 'pipe'],
-                env: cwd
-                    ? createWorkspaceProcessEnvironment(cwd, { PWD: cwd })
-                    : process.env,
-                detached: process.platform !== 'win32',
-                ...(cwd ? { cwd } : {}),
-            });
+            if (options.executionProvider) {
+                const handle = options.executionProvider.execute({
+                    phase: 'agent',
+                    target: options.executionTarget ?? null,
+                    command: cmd,
+                    args,
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                    launcherEnvironment: options.executionLauncherEnvironment ?? createHostLauncherEnvironment(),
+                    runtimeEnvironment: options.executionRuntimeEnvironment ?? createLegacyHostRuntimeEnvironment(cwd ?? process.cwd(), cwd ? { PWD: cwd } : {}),
+                    detached: process.platform !== 'win32',
+                    cwd: cwd ?? process.cwd(),
+                });
+                child = handle.child;
+                placementFailure = handle.placementFailure;
+                void placementFailure.then(failure => {
+                    if (failure) {
+                        rejectOnce(failure);
+                    }
+                });
+            }
+            else {
+                child = spawn(cmd, args, {
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                    env: cwd ? createWorkspaceProcessEnvironment(cwd, { PWD: cwd }) : process.env,
+                    detached: process.platform !== 'win32',
+                    ...(cwd ? { cwd } : {}),
+                });
+            }
         }
         catch (error) {
             const resolvedError = error instanceof Error ? error : new Error(String(error));
@@ -1144,9 +1184,11 @@ const runPlannerPromptOnce = (tool, model, variant, prompt, cwd, options = {}) =
                 killPlannerProcess(child, 'SIGTERM');
             }
         }
-        if (sessionTracking && tool === 'claude' && sessionId) {
-            hasResolvedSessionId = true;
-            updatePlanningSessionId(sessionTracking.ticketId, sessionId, sessionTracking.io);
+        if (sessionTracking?.resumeSessionId) {
+            bindResolvedProviderSession(sessionTracking.resumeSessionId);
+        }
+        else if (sessionTracking && tool === 'claude' && sessionId) {
+            bindResolvedProviderSession(sessionId);
         }
         if (sessionTracking && tool === 'opencode') {
             if (!sessionTracking.resumeSessionId) {
@@ -1166,8 +1208,11 @@ const runPlannerPromptOnce = (tool, model, variant, prompt, cwd, options = {}) =
                 tracker: subagentTracker,
                 discoverParentSession: false,
                 onParentSessionId: discoveredSessionId => {
-                    bindResolvedOpencodeSession(discoveredSessionId);
+                    bindResolvedProviderSession(discoveredSessionId);
                 },
+                taskSessionReader: opencodeSessionOperations
+                    ? createOpencodeTaskSessionReader(opencodeSessionOperations)
+                    : null,
             });
             opencodeSubagentMonitor.start();
         }
@@ -1214,7 +1259,7 @@ const runPlannerPromptOnce = (tool, model, variant, prompt, cwd, options = {}) =
                 }
                 subagentTracker?.handle(subagentEvents);
                 if (providerSessionId) {
-                    bindResolvedOpencodeSession(providerSessionId);
+                    bindResolvedProviderSession(providerSessionId);
                 }
                 if (isHiddenOpenTag.test(line)) {
                     insideHiddenBlock = true;
@@ -1239,6 +1284,11 @@ const runPlannerPromptOnce = (tool, model, variant, prompt, cwd, options = {}) =
             activePlannerProcesses.delete(child);
             options.cancellationState?.researchChildren.delete(child);
             clearWatchdogTimer();
+            const placementError = await placementFailure;
+            if (placementError) {
+                rejectOnce(placementError);
+                return;
+            }
             if (remainder.trim()) {
                 if (tool === 'claude') {
                     usageSnapshot = mergeUsageFromJsonLine(usageSnapshot, remainder);
@@ -1256,7 +1306,7 @@ const runPlannerPromptOnce = (tool, model, variant, prompt, cwd, options = {}) =
                 }
                 subagentTracker?.handle(subagentEvents);
                 if (providerSessionId) {
-                    bindResolvedOpencodeSession(providerSessionId);
+                    bindResolvedProviderSession(providerSessionId);
                 }
                 if (logFragment !== null) {
                     logLines.push(logFragment);
@@ -1284,11 +1334,16 @@ const runPlannerPromptOnce = (tool, model, variant, prompt, cwd, options = {}) =
                 sessionLookupTimer = null;
             }
             await opencodeSubagentMonitor?.refresh();
-            const hasPersistedCompletion = tool === 'opencode' && resolvedSessionId && spawnTimestamp
-                ? await opencodeSessionHasCompletedAssistantSince(resolvedSessionId, spawnTimestamp)
+            const hasPersistedCompletion = tool === 'opencode' && resolvedSessionId && spawnTimestamp && opencodeSessionOperations
+                ? await opencodeSessionOperations.hasCompletedAssistantSince(resolvedSessionId, spawnTimestamp)
                 : false;
             const persistedTranscript = hasPersistedCompletion && resolvedSessionId
-                ? await readOpencodeSessionTranscript({ sessionId: resolvedSessionId, since: spawnTimestamp ?? undefined, cwd: cwd ?? process.cwd() })
+                ? await readOpencodeSessionTranscript({
+                    sessionId: resolvedSessionId,
+                    since: spawnTimestamp ?? undefined,
+                    cwd: cwd ?? process.cwd(),
+                    ...(opencodeSessionOperations ? { sessionOperations: opencodeSessionOperations } : {}),
+                })
                 : null;
             const persistedResponse = persistedTranscript?.response?.trim() ?? '';
             const output = tool === 'opencode' && persistedResponse && (completionForced || hardTimeoutForced || !streamedOutput)
@@ -1370,7 +1425,10 @@ const runPlannerPromptOnce = (tool, model, variant, prompt, cwd, options = {}) =
                     return;
                 }
                 watchdogReadInFlight = true;
-                const completed = await opencodeSessionHasCompletedAssistantSince(resolvedSessionId, spawnTimestamp)
+                if (!opencodeSessionOperations) {
+                    return;
+                }
+                const completed = await opencodeSessionOperations.hasCompletedAssistantSince(resolvedSessionId, spawnTimestamp)
                     .catch(() => false);
                 watchdogReadInFlight = false;
                 if (settled) {
@@ -1652,6 +1710,7 @@ export const prepareLinkedPlanningResearch = async (taskDescription, options = {
             agentRunParent: resolvePlannerAgentRunParent(options),
             executionContext: options.executionContext,
             cancellationState: options.cancellationState,
+            ...plannerExecutionOptions(options),
             ...(selectionInvocation ? { mainRun: selectionInvocation } : {}),
         });
         decision = extractFirstJsonObject(output);
@@ -1674,24 +1733,145 @@ export const prepareLinkedPlanningResearch = async (taskDescription, options = {
         if (!linkedProject) {
             throw new Error(`Linked project ${request.project_id} is no longer available`);
         }
-        const invocation = createPlanningInvocation(options, `Linked Research: ${linkedProject.name}`, 'research');
+        const parentContext = options.executionContext;
+        if (!parentContext) {
+            const legacyInvocation = createPlanningInvocation(options, `Linked Research: ${linkedProject.name}`, 'research');
+            try {
+                const { output } = await runPlannerPrompt(tool, options.model ?? null, options.variant ?? null, prependSkillPromptBlock(buildLinkedProjectResearchPrompt(project, linkedProject, request), options.skills ?? []), linkedProject.repo_path, {
+                    agentRunParent: resolvePlannerAgentRunParent(options),
+                    cancellationState: options.cancellationState,
+                    ...(legacyInvocation ? { mainRun: legacyInvocation } : {}),
+                });
+                const result = normalizeLinkedResearchResponse(extractFirstJsonObject(output), linkedProject, request);
+                finalizePlanningInvocation(legacyInvocation, 'done', output);
+                return result;
+            }
+            catch (error) {
+                finalizePlanningInvocation(legacyInvocation, options.cancellationState?.stopRequested ? 'stopped' : 'error', error instanceof Error ? error.message : String(error));
+                throw error;
+            }
+        }
+        const childRun = createExecutionRun({
+            projectId: linkedProject.id,
+            kind: 'planning_agent',
+            domainStatus: 'queued',
+            sourceReference: { kind: 'project', id: linkedProject.id, label: linkedProject.name },
+            initiatedBy: 'automation',
+            metadata: {
+                linked_research_origin_project_id: project.id,
+                linked_research_origin_run_id: parentContext?.runId ?? null,
+                linked_research_origin_correlation_id: parentContext?.correlationId ?? null,
+                linked_research_question: request.question,
+                retry_tool: tool,
+                retry_model: options.model ?? null,
+                retry_variant: options.variant ?? null,
+                retry_skills: options.skills ?? [],
+                ...createExecutionProfileSelectionMetadata(linkedProject.id),
+            },
+            eventType: 'linked_research_created',
+        }, options.agentRunParent?.io);
+        const childContext = {
+            runId: childRun.id,
+            correlationId: childRun.correlation_id,
+            projectId: childRun.project_id,
+            kind: childRun.kind,
+        };
+        if (parentContext) {
+            addExecutionRunLink({
+                projectId: parentContext.projectId,
+                runId: parentContext.runId,
+                link: { entityType: 'project', entityId: linkedProject.id, relationship: 'context', label: linkedProject.name },
+            });
+        }
+        let childEnvironment = null;
+        let invocation = null;
         try {
-            const { output } = await runPlannerPrompt(tool, options.model ?? null, options.variant ?? null, prependSkillPromptBlock(buildLinkedProjectResearchPrompt(project, linkedProject, request), options.skills ?? []), linkedProject.repo_path, {
-                agentRunParent: resolvePlannerAgentRunParent(options),
-                executionContext: options.executionContext,
+            transitionExecutionRun({
+                projectId: childContext.projectId,
+                runId: childContext.runId,
+                status: 'running',
+                domainStatus: 'running',
+                eventType: 'linked_research_started',
+            });
+            const resolvedTarget = await resolveProjectRootExecutionTarget(linkedProject);
+            const executionTarget = {
+                identity: resolvedTarget.identity,
+                workspacePath: resolvedTarget.workspacePath,
+                workspaceEvidence: resolvedTarget.workspaceEvidence,
+            };
+            childEnvironment = await resolveWorkloadExecutionEnvironment({
+                project: linkedProject,
+                executionRunId: childContext.runId,
+                agent: tool,
+                model: options.model ?? null,
+                skills: options.skills ?? [],
+                target: executionTarget,
+                workload: 'plan',
+            });
+            const invocationId = createAgentRun({
+                executionRunId: childContext.runId,
+                parentType: 'planning',
+                parentId: linkedProject.id,
+                label: `Linked Research: ${linkedProject.name}`,
+                role: 'research',
+            });
+            const invocationRun = getAgentRun(invocationId);
+            if (!invocationRun) {
+                throw new Error('Unable to create the linked research agent run');
+            }
+            invocation = {
+                parentType: 'planning',
+                parentId: linkedProject.id,
+                id: invocationRun.id,
+                runIndex: invocationRun.run_index,
+                label: invocationRun.label,
+                role: invocationRun.role,
+            };
+            const { output } = await runPlannerPrompt(tool, options.model ?? null, options.variant ?? null, prependSkillPromptBlock(buildLinkedProjectResearchPrompt(project, linkedProject, request), options.skills ?? []), resolvedTarget.workspacePath, {
+                agentRunParent: options.agentRunParent
+                    ? { parentType: 'planning', parentId: linkedProject.id, io: options.agentRunParent.io }
+                    : undefined,
+                executionContext: childContext,
                 cancellationState: options.cancellationState,
+                executionProvider: childEnvironment.provider,
+                executionTarget,
+                executionLauncherEnvironment: childEnvironment.launcherEnvironment,
+                executionRuntimeEnvironment: childEnvironment.runtimeEnvironment,
                 ...(invocation ? { mainRun: invocation } : {}),
             });
             const result = normalizeLinkedResearchResponse(extractFirstJsonObject(output), linkedProject, request);
             finalizePlanningInvocation(invocation, 'done', output);
+            transitionExecutionRun({
+                projectId: childContext.projectId,
+                runId: childContext.runId,
+                status: 'completed',
+                domainStatus: 'done',
+                eventType: 'linked_research_completed',
+            });
             return result;
         }
         catch (error) {
             finalizePlanningInvocation(invocation, options.cancellationState?.stopRequested ? 'stopped' : 'error', error instanceof Error ? error.message : String(error));
-            throw error;
+            transitionExecutionRun({
+                projectId: childContext.projectId,
+                runId: childContext.runId,
+                status: options.cancellationState?.stopRequested ? 'cancelled' : 'failed',
+                domainStatus: options.cancellationState?.stopRequested ? 'stopped' : 'error',
+                ...(options.cancellationState?.stopRequested ? {} : {
+                    failure: { code: 'linked_research_failed', message: error instanceof Error ? error.message : String(error) },
+                }),
+                eventType: options.cancellationState?.stopRequested ? 'linked_research_cancelled' : 'linked_research_failed',
+            });
+            if (options.cancellationState?.stopRequested) {
+                throw error;
+            }
+            return null;
+        }
+        finally {
+            await childEnvironment?.release();
         }
     }));
-    return linkedResearch;
+    return linkedResearch.filter((result) => result !== null);
 };
 export const generatePlanText = (title, description, options = {}) => {
     const tool = options.tool ?? config.tool ?? 'opencode';
@@ -1707,7 +1887,7 @@ export const generatePlanText = (title, description, options = {}) => {
             description,
             ...(invocation ? { invocation: { parentType: invocation.parentType, parentId: invocation.parentId, agentRunId: invocation.id } } : {}),
         });
-        const { output: plannerOutput, responseTiming: plannerTiming, usageSnapshot, transcriptRuns } = await runPlannerPrompt(tool, options.model ?? null, options.variant ?? null, prependSkillPromptBlock(buildSingleTicketPrompt(title, description, linkedResearchContext, projectMemoryBlock, Boolean(project?.memory_enabled), Boolean(options.ticketId)), options.skills ?? []), resolvePlannerCwd(project, options.branch), {
+        const { output: plannerOutput, responseTiming: plannerTiming, usageSnapshot, transcriptRuns } = await runPlannerPrompt(tool, options.model ?? null, options.variant ?? null, prependSkillPromptBlock(buildSingleTicketPrompt(title, description, linkedResearchContext, projectMemoryBlock, Boolean(project?.memory_enabled), Boolean(options.ticketId)), options.skills ?? []), options.cwd ?? resolvePlannerCwd(project, options.branch), {
             onProgress: options.onProgress,
             ...(options.ticketId && options.io
                 ? {
@@ -1725,6 +1905,7 @@ export const generatePlanText = (title, description, options = {}) => {
                 : {}),
             executionContext: options.executionContext,
             cancellationState: options.cancellationState,
+            ...plannerExecutionOptions(options),
             ...(invocation ? { mainRun: invocation } : {}),
         });
         try {
@@ -1788,9 +1969,10 @@ export const generatePlanningTicketOutline = async (description, options = {}) =
             description,
             ...(invocation ? { invocation: { parentType: invocation.parentType, parentId: invocation.parentId, agentRunId: invocation.id } } : {}),
         });
-        const { output } = await runPlannerPrompt(tool, options.model ?? null, options.variant ?? null, prependSkillPromptBlock(buildPlanningAgentOutlinePrompt(description, linkedResearchContext, projectMemoryBlock), options.skills ?? []), resolvePlannerCwd(project, options.branch), {
+        const { output } = await runPlannerPrompt(tool, options.model ?? null, options.variant ?? null, prependSkillPromptBlock(buildPlanningAgentOutlinePrompt(description, linkedResearchContext, projectMemoryBlock), options.skills ?? []), options.cwd ?? resolvePlannerCwd(project, options.branch), {
             agentRunParent: resolvePlannerAgentRunParent(options),
             executionContext: options.executionContext,
+            ...plannerExecutionOptions(options),
             ...(invocation ? { mainRun: invocation } : {}),
         });
         const result = extractFirstJsonObject(output);
@@ -1816,9 +1998,10 @@ export const expandPlanningTicketOutline = async (description, outline, options
             description,
             ...(invocation ? { invocation: { parentType: invocation.parentType, parentId: invocation.parentId, agentRunId: invocation.id } } : {}),
         });
-        const { output } = await runPlannerPrompt(tool, options.model ?? null, options.variant ?? null, prependSkillPromptBlock(buildPlanningAgentExpansionPrompt(description, outline, linkedResearchContext, projectMemoryBlock), options.skills ?? []), resolvePlannerCwd(project, options.branch), {
+        const { output } = await runPlannerPrompt(tool, options.model ?? null, options.variant ?? null, prependSkillPromptBlock(buildPlanningAgentExpansionPrompt(description, outline, linkedResearchContext, projectMemoryBlock), options.skills ?? []), options.cwd ?? resolvePlannerCwd(project, options.branch), {
             agentRunParent: resolvePlannerAgentRunParent(options),
             executionContext: options.executionContext,
+            ...plannerExecutionOptions(options),
             ...(invocation ? { mainRun: invocation } : {}),
         });
         const result = extractFirstJsonObject(output);
@@ -1880,6 +2063,8 @@ export const startPlan = (ticket, io, options = {}) => {
     };
     const targetBundleId = options.targetBundleId === undefined ? ticket.worktree_bundle_id : options.targetBundleId;
     const targetBranch = options.branch === undefined ? resolveTicketBranch(ticket) : options.branch;
+    const runTool = resolveTicketTool(ticket, config.tool ?? 'opencode');
+    const runSkills = options.skills ?? ticket.skills ?? [];
     const executionRun = createExecutionRun({
         projectId: project.id,
         kind: 'plan',
@@ -1895,6 +2080,11 @@ export const startPlan = (ticket, io, options = {}) => {
             ...(initiation.workflowContext ?? {}),
             plan_target_bundle_id: targetBundleId,
             plan_target_branch: targetBranch,
+            retry_tool: runTool,
+            retry_model: ticket.model,
+            retry_variant: ticket.variant,
+            retry_skills: runSkills,
+            ...createExecutionProfileSelectionMetadata(project.id),
         },
         eventType: initiation.retrySourceRunId ? 'retry_started' : 'plan_created',
     }, io);
@@ -1911,6 +2101,7 @@ export const startPlan = (ticket, io, options = {}) => {
         queuedJob = enqueue(jobKey, async () => {
             let callbackStarted = false;
             let activityRegistered = false;
+            let workloadEnvironment = null;
             try {
                 registerBundleActivity(ticket, 'plan');
                 activityRegistered = true;
@@ -1946,18 +2137,60 @@ export const startPlan = (ticket, io, options = {}) => {
                 }
                 const planningDescription = await resolveExternalPlanningDescription(project.id, ticket.description);
                 const initiativePrompt = ticket.planning_context?.initiative_prompt?.trim() || planningDescription;
+                const resolvedTarget = targetBranch
+                    ? await resolveExecutionTarget({
+                        project,
+                        descriptor: classifyTicketExecutionTarget({
+                            branch: targetBranch,
+                            bundleId: targetBundleId,
+                            bundleKind: currentTicket.bundle?.kind ?? null,
+                        }),
+                    })
+                    : await resolveProjectRootExecutionTarget(project);
+                const executionTarget = {
+                    identity: resolvedTarget.identity,
+                    workspacePath: resolvedTarget.workspacePath,
+                    workspaceEvidence: resolvedTarget.workspaceEvidence,
+                };
+                workloadEnvironment = await resolveWorkloadExecutionEnvironment({
+                    project,
+                    executionRunId: executionContext.runId,
+                    agent: runTool,
+                    model: ticket.model,
+                    skills: runSkills,
+                    target: executionTarget,
+                    workload: 'plan',
+                });
+                const planningSessionId = options.providerContinuation === 'fresh' ? null : ticket.planning_session_id;
+                if (planningSessionId) {
+                    assertProviderSessionAuthorityMatches({
+                        projectId: project.id,
+                        currentExecutionRunId: executionContext.runId,
+                        parentType: 'ticket',
+                        parentId: ticket.id,
+                        sessionId: planningSessionId,
+                        agent: runTool,
+                        modelProvider: runTool === 'claude' ? 'anthropic' : getModelProvider(ticket.model),
+                        authority: workloadEnvironment.runAuthority,
+                    });
+                }
                 const planned = await generatePlanText(ticket.title, planningDescription, {
-                    tool: resolveTicketTool(ticket, config.tool ?? 'opencode'),
+                    tool: runTool,
                     model: ticket.model,
                     variant: ticket.variant,
-                    skills: options.skills ?? ticket.skills ?? [],
+                    skills: runSkills,
                     projectId: project.id,
                     branch: targetBranch,
-                    planningSessionId: options.providerContinuation === 'fresh' ? null : ticket.planning_session_id,
+                    cwd: resolvedTarget.workspacePath,
+                    planningSessionId,
                     ticketId: ticket.id,
                     io,
                     executionContext,
                     cancellationState,
+                    executionProvider: workloadEnvironment.provider,
+                    executionTarget,
+                    executionLauncherEnvironment: workloadEnvironment.launcherEnvironment,
+                    executionRuntimeEnvironment: workloadEnvironment.runtimeEnvironment,
                     onProgress: progress => {
                         updatePlanningProgress(ticket.id, progress.log, progress.response, io);
                     },
@@ -1980,7 +2213,13 @@ export const startPlan = (ticket, io, options = {}) => {
                 if (resolvedTool === 'opencode') {
                     const freshTicket = getTicket(ticket.id);
                     if (freshTicket?.planning_session_id) {
-                        await storeTicketUsageSnapshot(freshTicket.id, freshTicket.planning_session_id);
+                        const sessionOperations = workloadEnvironment.provider?.sessionOperations?.opencode;
+                        if (sessionOperations) {
+                            await storeTicketUsageSnapshot(freshTicket.id, freshTicket.planning_session_id, sessionOperations);
+                        }
+                        else {
+                            await storeTicketUsageSnapshot(freshTicket.id, freshTicket.planning_session_id);
+                        }
                     }
                 }
                 else if (resolvedTool === 'claude' && planned.usageSnapshot) {
@@ -2136,11 +2375,19 @@ export const startPlan = (ticket, io, options = {}) => {
                 }, io);
             }
             finally {
-                if (activityRegistered) {
-                    unregisterBundleActivity(ticket, 'plan');
+                try {
+                    await workloadEnvironment?.release();
+                }
+                catch {
+                    // Cleanup failure must not replace the durable Plan outcome.
                 }
-                if (activePlanProcesses.get(ticket.id) === cancellationState) {
-                    activePlanProcesses.delete(ticket.id);
+                finally {
+                    if (activityRegistered) {
+                        unregisterBundleActivity(ticket, 'plan');
+                    }
+                    if (activePlanProcesses.get(ticket.id) === cancellationState) {
+                        activePlanProcesses.delete(ticket.id);
+                    }
                 }
             }
         });