/**

* Forge Execution Service - Command Bus Interface

*

* Shared execution service for plan execution and loop lifecycle.

* Provides a unified interface for internal tools, API, and TUI surfaces.

*/

import type { PluginConfig, Logger } from '../types'

import type { OpencodeClient } from '@opencode-ai/sdk/v2'

import type { PlansRepo } from '../storage/repos/plans-repo'

import type { LoopsRepo } from '../storage/repos/loops-repo'

import type { createLoopEventHandler } from '../hooks'

import type { SandboxManager } from '../sandbox/manager'

import { extractPlanExecutionMetadata } from '../utils/plan-execution'

import { parseModelString, retryWithModelFallback } from '../utils/model-fallback'

import { formatLoopSessionTitle, formatPlanSessionTitle } from '../utils/session-titles'

import { buildLoopPermissionRuleset, buildAuditSessionPermissionRuleset } from '../constants/loop'

import { findPartialMatch } from '../utils/partial-match'

import { isSandboxEnabled } from '../sandbox/context'

import { createLoopSessionWithWorkspace, publishWorkspaceDetachedToast } from '../utils/loop-session'

import { aggregateToUsageSummary } from '../utils/loop-format'

import { join } from 'path'

import { existsSync } from 'fs'

import { decomposeDeterministically } from './deterministic-decomposer'

import { markPromptSent, clearPromptPending, terminationStatusFor, parseTerminationReasonString } from '../loop'

import {

withInFlightGuard,

ConcurrentPromptError,

type PromptAgent,

} from '../loop/in-flight-guard'

import { getRestartability, type RestartBlockedReason } from '../loop/restartability'

// ============================================================================

// Surface Types - Identifies the caller boundary

// ============================================================================

export type ForgeExecutionSurface = 'tool' | 'approval-hook' | 'api' | 'tui'

// ============================================================================

// Request Context

// ============================================================================

export interface ForgeExecutionRequestContext {

surface: ForgeExecutionSurface

projectId: string

directory: string

sourceSessionId?: string

requestId?: string

}

// ============================================================================

// Plan Source Types

// ============================================================================

export type PlanSource =

| { kind: 'inline'; planText: string }

| { kind: 'stored'; sessionId: string }

| { kind: 'loop-state'; loopName: string }

// ============================================================================

// Loop Extra / Attach Types

// ============================================================================

export interface ForgeLoopExtra {

hostSessionId?: string

title?: string

executionModel?: string

auditorModel?: string

executionVariant?: string

auditorVariant?: string

planSource: 'stored' | 'inline'

planText?: string

initialPromptOwner?: 'server' | 'tui'

pendingAttachStartedAt?: number

}

export interface AttachLoopInput {

sessionId: string

workspaceId?: string

worktreeDir: string

worktreeBranch?: string

loopName: string

displayName: string

executionName: string

hostSessionId?: string

executionModel?: string

auditorModel?: string

executionVariant?: string

auditorVariant?: string

maxIterations: number

sandboxEnabled: boolean

sandboxContainer?: string

planText: string

selectSession?: boolean

selectSessionTiming?: 'after-create' | 'after-prompt'

startWatchdog?: boolean

sendInitialPrompt?: boolean

abortSourceSessionOnSuccess?: boolean

onStarted?: (info: {

sessionId: string

loopName: string

displayName: string

worktreeDir?: string

workspaceId?: string

}) => void

}

// ============================================================================

// Loop Selector Types

// ============================================================================

export type LoopSelector =

| { kind: 'exact'; name: string }

| { kind: 'partial'; name: string }

| { kind: 'only-active' }

// ============================================================================

// Command Types - Discriminated Union

// ============================================================================

export interface ExecutePlanNewSessionCommand {

type: 'plan.execute.newSession'

source: PlanSource

title?: string

executionModel?: string

lifecycle?: {

selectSession?: boolean

selectSessionTiming?: 'after-create' | 'after-prompt'

abortSourceSession?: boolean

deleteSessionOnPromptFailure?: boolean

returnToSourceOnPromptFailure?: boolean

}

}

export interface ExecutePlanHereCommand {

type: 'plan.execute.here'

source: PlanSource

targetSessionId: string

title?: string

executionModel?: string

}

export interface StartLoopCommand {

type: 'loop.start'

source: PlanSource

title?: string

loopName?: string

maxIterations?: number

executionModel?: string

auditorModel?: string

executionVariant?: string

auditorVariant?: string

hostSessionId?: string

lifecycle?: {

selectSession?: boolean

selectSessionTiming?: 'after-create' | 'after-prompt'

startWatchdog?: boolean

abortSourceSessionOnSuccess?: boolean

onStarted?: (info: {

sessionId: string

loopName: string

displayName: string

worktreeDir?: string

workspaceId?: string

}) => void

}

}

export interface BuildStartLoopCommandInput {

source: PlanSource

title?: string

loopName?: string

maxIterations?: number

executionModel?: string

auditorModel?: string

executionVariant?: string

auditorVariant?: string

hostSessionId?: string

lifecycle?: StartLoopCommand['lifecycle']

}

export function buildStartLoopCommand(input: BuildStartLoopCommandInput): StartLoopCommand {

return {

type: 'loop.start',

source: input.source,

title: input.title,

loopName: input.loopName,

maxIterations: input.maxIterations,

executionModel: input.executionModel,

auditorModel: input.auditorModel,

executionVariant: input.executionVariant,

auditorVariant: input.auditorVariant,

hostSessionId: input.hostSessionId,

lifecycle: input.lifecycle,

}

}

export interface RestartLoopCommand {

type: 'loop.restart'

selector: LoopSelector

force?: boolean

}

export interface CancelLoopCommand {

type: 'loop.cancel'

selector?: LoopSelector

cleanupWorktree?: boolean

}

export interface GetLoopStatusCommand {

type: 'loop.status'

selector?: LoopSelector

includeRecent?: boolean

includeSessionOutput?: boolean

limit?: number

}

export type ForgeExecutionCommand =

| ExecutePlanNewSessionCommand

| ExecutePlanHereCommand

| StartLoopCommand

| RestartLoopCommand

| CancelLoopCommand

| GetLoopStatusCommand

// ============================================================================

// Response/Error Types

// ============================================================================

export interface ForgeExecutionError {

code: 'bad_request' | 'not_found' | 'conflict' | 'disabled' | 'prompt_failed' | 'lifecycle_failed' | 'internal_error'

status: number

message: string

candidates?: string[]

details?: Record<string, unknown>

}

export interface ForgeExecutionWarning {

code: string

message: string

}

export type ForgeExecutionResponse<T> =

| { ok: true; data: T; warnings?: ForgeExecutionWarning[] }

| { ok: false; error: ForgeExecutionError }

// ============================================================================

// Result Types per Command

// ============================================================================

export interface PlanExecutionStartedResult {

operation: 'plan.execute.newSession' | 'plan.execute.here'

mode: 'new-session' | 'execute-here'

sessionId: string

modelUsed: string | null

title: string

}

export interface LoopStartedResult {

operation: 'loop.start'

sessionId: string

loopName: string

displayName: string

executionName: string

worktreeDir?: string

worktreeBranch?: string

workspaceId?: string

hostSessionId?: string

modelUsed: string | null

maxIterations: number

deduped?: boolean

}

export interface LoopRestartedResult {

operation: 'loop.restart'

loopName: string

sessionId: string

previousSessionId: string

worktreeDir?: string

worktreeBranch?: string

worktree: boolean

sandbox: boolean

bindFailed: boolean

iteration: number

}

export interface LoopCancelledResult {

operation: 'loop.cancel'

loopName: string

sessionId: string

iteration: number

worktreeDir?: string

worktreeRemoved: boolean

worktree: boolean

worktreeBranch?: string

}

export interface LoopStatusView {

loopName: string

displayName: string

status: 'running' | 'completed' | 'cancelled' | 'errored' | 'stalled'

phase?: string

iteration: number

maxIterations: number

sessionId: string

active: boolean

startedAt: string

completedAt?: string

terminationReason?: string

worktree: boolean

worktreeDir?: string

worktreeBranch?: string

executionModel?: string

auditorModel?: string

workspaceId?: string

hostSessionId?: string

currentSectionIndex?: number

totalSections?: number

finalAuditDone?: boolean

usage?: import('../loop/token-usage').LoopUsageSummary

restartable: boolean

restartRequiresForce: boolean

restartBlockedReason?: RestartBlockedReason

restartBlockedMessage?: string

sections?: Array<{

index: number

title: string

status: string

attempts: number

startedAt?: number | null

completedAt?: number | null

summaryDone: string | null

summaryDeviations: string | null

summaryFollowUps: string | null

}>

}

export interface LoopStatusResult {

operation: 'loop.status'

loops: LoopStatusView[]

active: LoopStatusView[]

recent: LoopStatusView[]

}

// Type mapping from command to result

export type ForgeExecutionResult<C extends ForgeExecutionCommand> =

C extends ExecutePlanNewSessionCommand ? PlanExecutionStartedResult :

C extends ExecutePlanHereCommand ? PlanExecutionStartedResult :

C extends StartLoopCommand ? LoopStartedResult :

C extends RestartLoopCommand ? LoopRestartedResult :

C extends CancelLoopCommand ? LoopCancelledResult :

C extends GetLoopStatusCommand ? LoopStatusResult :

never

// ============================================================================

// Service Interface

// ============================================================================

export interface ForgeExecutionService {

dispatch<C extends ForgeExecutionCommand>(

ctx: ForgeExecutionRequestContext,

command: C,

): Promise<ForgeExecutionResponse<ForgeExecutionResult<C>>>

}

// ============================================================================

// Service Dependencies

// ============================================================================

export interface ForgeExecutionServiceDeps {

projectId: string

directory: string

config: PluginConfig

logger: Logger | Console

dataDir: string

v2: OpencodeClient

legacyClient?: import('@opencode-ai/sdk').OpencodeClient

plansRepo: PlansRepo

loopsRepo: LoopsRepo

loopHandler?: ReturnType<typeof createLoopEventHandler>

loop: import('../loop/runtime').Loop

sandboxManager?: SandboxManager | null

sectionPlansRepo?: import('../storage/repos/section-plans-repo').SectionPlansRepo

reviewFindingsRepo?: import('../storage/repos/review-findings-repo').ReviewFindingsRepo

loopSessionUsageRepo?: import('../storage/repos/loop-session-usage-repo').LoopSessionUsageRepo

workspaceStatusRegistry: import('../utils/workspace-status-registry').WorkspaceStatusRegistry

pendingTeardowns: import('../workspace/pending-teardown').PendingTeardownRegistry

}

// ============================================================================

// Helper Functions

// ============================================================================

function ok<T>(data: T, warnings?: ForgeExecutionWarning[]): ForgeExecutionResponse<T> {

return { ok: true, data, warnings }

}

function fail(

code: ForgeExecutionError['code'],

status: number,

message: string,

details?: Record<string, unknown>,

candidates?: string[]

): ForgeExecutionResponse<never> {

return {

ok: false,

error: { code, status, message, details, candidates }

}

}

// ============================================================================

// Plan Source Resolution

// ============================================================================

async function resolvePlanSource(

ctx: ForgeExecutionRequestContext,

source: PlanSource,

deps: ForgeExecutionServiceDeps,

): Promise<{ ok: true; planText: string } | { ok: false; error: ForgeExecutionError }> {

switch (source.kind) {

case 'inline': {

return { ok: true, planText: source.planText }

}

case 'stored': {

const planRow = deps.plansRepo.getForSession(ctx.projectId, source.sessionId)

if (!planRow) {

return {

ok: false,

error: {

code: 'not_found',

status: 404,

message: 'Plan not found for session',

}

}

}

return { ok: true, planText: planRow.content }

}

case 'loop-state': {

const planText = deps.loop.getPlanText(source.loopName, ctx.sourceSessionId ?? '')

if (planText) {

return { ok: true, planText }

}

return {

ok: false,

error: {

code: 'not_found',

status: 404,

message: 'Plan not found in loop state',

}

}

}

}

}

// ============================================================================

// Fallback Helpers for Legacy Plugin SDK

// ============================================================================

interface SessionCreateInput {

title: string

directory: string

permission?: ReturnType<typeof import('../constants/loop').buildLoopPermissionRuleset>

}

interface SessionCreateResult {

data?: { id: string }

error?: unknown

}

interface SessionPromptInput {

sessionID: string

directory: string

parts: Array<{ type: 'text'; text: string }>

agent: string

model?: { providerID: string; modelID: string }

workspace?: string

}

interface SessionPromptResult {

data?: unknown

error?: unknown

}

async function createSessionWithFallback(

deps: ForgeExecutionServiceDeps,

input: SessionCreateInput,

): Promise<SessionCreateResult> {

// Try v2 SDK first

try {

const result = await deps.v2.session.create({

title: input.title,

directory: input.directory,

...(input.permission ? { permission: input.permission } : {}),

})

if (result.data) {

return { data: result.data }

}

if (result.error) {

const errorMsg = result.error instanceof Error ? result.error.message : String(result.error)

if (errorMsg.includes('Unable to connect')) {

deps.logger.log('createSessionWithFallback: v2 SDK unavailable, falling back to legacy SDK')

} else {

deps.logger.error('createSessionWithFallback: v2 SDK error', result.error)

}

}

} catch (err) {

const errorMsg = err instanceof Error ? err.message : String(err)

if (errorMsg.includes('Unable to connect')) {

deps.logger.log('createSessionWithFallback: v2 SDK threw connection error, falling back to legacy SDK')

} else {

deps.logger.error('createSessionWithFallback: v2 SDK threw error', err)

}

}

// Fallback to legacy SDK

if (!deps.legacyClient) {

deps.logger.error('createSessionWithFallback: no legacy SDK available')

return { error: new Error('No legacy SDK available') }

}

try {

const result = await deps.legacyClient.session.create({

body: {

title: input.title,

...(input.permission ? { permission: input.permission } : {}),

},

query: {

directory: input.directory,

},

} as Parameters<typeof deps.legacyClient.session.create>[0])

const session = result.data as { id?: string } | undefined

if (session?.id) {

return { data: { id: session.id } }

}

return { error: new Error('Legacy SDK returned no session ID') }

} catch (err) {

deps.logger.error('createSessionWithFallback: legacy SDK failed', err)

return { error: err }

}

}

async function promptSessionWithFallback(

deps: ForgeExecutionServiceDeps,

input: SessionPromptInput,

model?: { providerID: string; modelID: string },

): Promise<{ result: SessionPromptResult; usedModel?: typeof model }> {

// Try v2 SDK first

try {

const result = await deps.v2.session.promptAsync({

sessionID: input.sessionID,

directory: input.directory,

parts: input.parts,

agent: input.agent,

...(model ? { model } : {}),

...(input.workspace ? { workspace: input.workspace } : {}),

})

if (!result.error) {

return { result: { data: result.data }, usedModel: model }

}

const errorMsg = result.error instanceof Error ? result.error.message : String(result.error)

if (errorMsg.includes('Unable to connect')) {

deps.logger.log('promptSessionWithFallback: v2 SDK unavailable, falling back to legacy SDK')

} else {

deps.logger.error('promptSessionWithFallback: v2 SDK error', result.error)

}

} catch (err) {

const errorMsg = err instanceof Error ? err.message : String(err)

if (errorMsg.includes('Unable to connect')) {

deps.logger.log('promptSessionWithFallback: v2 SDK threw connection error, falling back to legacy SDK')

} else {

deps.logger.error('promptSessionWithFallback: v2 SDK threw error', err)

}

}

// Fallback to legacy SDK

if (!deps.legacyClient) {

deps.logger.error('promptSessionWithFallback: no legacy SDK available')

return { result: { error: new Error('No legacy SDK available') }, usedModel: model }

}

try {

const legacyResult = await deps.legacyClient.session.promptAsync({

path: { id: input.sessionID },

query: {

directory: input.directory,

...(input.workspace ? { workspace: input.workspace } : {}),

},

body: {

agent: input.agent,

parts: input.parts,

...(model ? { model } : {}),

},

} as Parameters<typeof deps.legacyClient.session.promptAsync>[0])

// Legacy SDK returns { data, request, response }

const legacyData = legacyResult as { data?: unknown }

if (!legacyData.data) {

return { result: { error: new Error('Legacy SDK returned no data') }, usedModel: model }

}

return { result: { data: legacyData.data }, usedModel: model }

} catch (err) {

deps.logger.error('promptSessionWithFallback: legacy SDK failed', err)

return { result: { error: err }, usedModel: model }

}

}

async function selectSessionWithFallback(

deps: ForgeExecutionServiceDeps,

selection: { sessionID: string; workspace?: string },

): Promise<void> {

const maxAttempts = 3

const backoffMs = 250

async function attemptSelectSession(attempt: number): Promise<{ ok: boolean; retryable: boolean }> {

try {

await deps.v2.tui!.selectSession({

sessionID: selection.sessionID,

...(selection.workspace ? { workspace: selection.workspace } : {}),

})

deps.logger.log(`[warp] select.v2.selectSession ok attempt=${attempt}`)

return { ok: true, retryable: false }

} catch (err) {

const errorMsg = err instanceof Error ? err.message : String(err)

deps.logger.log(`[warp] select.v2.selectSession failed attempt=${attempt} error="${errorMsg}"`)

const retryable = errorMsg.includes('Unable to connect')

if (retryable) {

deps.logger.log('selectSessionWithFallback: v2 TUI unavailable, will retry then fall back to publish')

} else {

deps.logger.error('selectSessionWithFallback: v2 TUI error', err)

}

return { ok: false, retryable }

}

}

if (deps.v2.tui) {

for (let attempt = 1; attempt <= maxAttempts; attempt++) {

const result = await attemptSelectSession(attempt)

if (result.ok) return

if (!result.retryable) break

if (attempt < maxAttempts) {

await new Promise(resolve => setTimeout(resolve, backoffMs))

}

}

} else {

deps.logger.log('[warp] select.v2.selectSession skipped reason=no-v2-tui')

}

try {

if (!deps.v2.tui) {

deps.logger.log('[warp] select.v2.publish skipped reason=no-v2-tui')

} else {

await deps.v2.tui.publish({

directory: deps.directory,

body: {

type: 'tui.session.select',

properties: {

sessionID: selection.sessionID,

...(selection.workspace ? { workspace: selection.workspace } : {}),

},

},

})

deps.logger.log('[warp] select.v2.publish ok')

return

}

} catch (err) {

const errorMsg = err instanceof Error ? err.message : String(err)

deps.logger.log(`[warp] select.v2.publish failed error="${errorMsg}"`)

if (errorMsg.includes('Unable to connect')) {

deps.logger.log('selectSessionWithFallback: v2 TUI publish unavailable, falling back to legacy SDK')

} else {

deps.logger.error('selectSessionWithFallback: v2 TUI publish error', err)

}

}

if (!deps.legacyClient?.tui) {

deps.logger.log('[warp] select.legacy.publish skipped reason=no-legacy-tui')

deps.logger.error('selectSessionWithFallback: no legacy TUI available')

return

}

try {

await deps.legacyClient.tui.publish({

body: {

type: 'tui.session.select',

properties: {

sessionID: selection.sessionID,

...(selection.workspace ? { workspace: selection.workspace } : {}),

},

},

} as unknown as Parameters<typeof deps.legacyClient.tui.publish>[0])

deps.logger.log('[warp] select.legacy.publish ok')

} catch (err) {

const errorMsg = err instanceof Error ? err.message : String(err)

deps.logger.log(`[warp] select.legacy.publish failed error="${errorMsg}"`)

deps.logger.error('selectSessionWithFallback: legacy TUI failed', err)

}

}

export interface SelectInitialWorktreeSessionOpts {

selectSession: boolean | undefined

logger: Logger | Console

workspaceStatusRegistry: import('../utils/workspace-status-registry').WorkspaceStatusRegistry

selectSessionFn: (selection: { sessionID: string; workspace?: string }) => Promise<void>

/** Maximum time to wait for selectSessionFn before falling through. Defaults to 2000ms. */

selectTimeoutMs?: number

}

export async function selectInitialWorktreeSession(

targetSessionId: string,

boundWorkspaceId: string | undefined,

context: string,

opts: SelectInitialWorktreeSessionOpts,

): Promise<void> {

opts.logger.log(`[warp] select.entry context="${context}" targetSessionId=${targetSessionId} workspaceId=${boundWorkspaceId ?? 'none'}`)

if (!opts.selectSession) {

opts.logger.log(`[warp] select.exit context="${context}" reason=no-select-session`)

return

}

if (!boundWorkspaceId) {

opts.logger.log(`[warp] select.exit context="${context}" reason=no-workspace`)

return

}

const totalStart = Date.now()

try {

const connectedResult = await opts.workspaceStatusRegistry.awaitConnected(boundWorkspaceId, {

timeoutMs: 5000,

logger: opts.logger as Logger,

})

const readyElapsedMs = Date.now() - totalStart

if (connectedResult.connected) {

opts.logger.log(

`[warp] select.ready context="${context}" source=${connectedResult.source} elapsedMs=${readyElapsedMs}`,

)

} else {

opts.logger.log(

`[warp] select.degraded context="${context}" reason="${connectedResult.reason ?? 'unknown'}" lastStatus="${connectedResult.lastStatus ?? 'none'}" elapsedMs=${readyElapsedMs}`,

)

}

const envTimeout = Number(process.env.FORGE_SELECT_TIMEOUT_MS)

const SELECT_TIMEOUT_MS = opts.selectTimeoutMs ?? (Number.isFinite(envTimeout) && envTimeout > 0 ? envTimeout : 2000)

await Promise.race([

opts.selectSessionFn({ sessionID: targetSessionId, workspace: boundWorkspaceId }),

new Promise<void>((resolve) => setTimeout(resolve, SELECT_TIMEOUT_MS)),

])

const totalMs = Date.now() - totalStart

opts.logger.log(`[warp] select.complete context="${context}" totalMs=${totalMs}`)

} catch (err) {

const totalMs = Date.now() - totalStart

opts.logger.error(

`[warp] select.failed context="${context}" error="${err instanceof Error ? err.message : String(err)}" totalMs=${totalMs}`,

)

}

}

// ============================================================================

// attachLoopToSession

// ============================================================================

export async function attachLoopToSession(

deps: ForgeExecutionServiceDeps,

ctx: ForgeExecutionRequestContext,

input: AttachLoopInput,

): Promise<{ ok: true; loopName: string } | { ok: false; code: 'already_attached' | 'conflict' | 'internal_error' | 'prompt_failed'; message: string }> {

const {

sessionId,

workspaceId,

worktreeDir,

worktreeBranch,

loopName,

displayName,

executionModel,

auditorModel,

executionVariant,

auditorVariant,

maxIterations,

sandboxEnabled,

sandboxContainer,

planText,

selectSession,

selectSessionTiming,

startWatchdog,

sendInitialPrompt = true,

abortSourceSessionOnSuccess,

onStarted,

} = input

const loopModel = parseModelString(executionModel)

const existing = deps.loopsRepo.get(ctx.projectId, loopName)

if (existing) {

if (existing.status === 'running') {

deps.logger.log(`attachLoopToSession: loop ${loopName} already attached (running), skipping`)

return { ok: false, code: 'already_attached', message: `Loop ${loopName} is already attached` }

}

deps.logger.log(`attachLoopToSession: loop ${loopName} has terminal status ${existing.status}; refusing attach`)

return { ok: false, code: 'conflict', message: `Loop ${loopName} is terminal. Use loop restart to resume or start a new suffixed loop.` }

}

// Defensive purge of orphaned per-loop rows (section_plans cascade may not have fired

// historically; plans/review_findings have no FK). Idempotent.

try {

const removedSections = deps.sectionPlansRepo?.deleteAll(ctx.projectId, loopName) ?? 0

deps.plansRepo.deleteForLoop(ctx.projectId, loopName)

deps.reviewFindingsRepo?.deleteByLoopName(ctx.projectId, loopName)

if (removedSections > 0) {

deps.logger.log(`attachLoopToSession: purged ${removedSections} orphaned section_plans rows for ${loopName}`)

}

} catch (err) {

deps.logger.error(`attachLoopToSession: failed to purge orphaned per-loop rows for ${loopName}`, err)

// Non-fatal — proceed.

}

try {

// Persist loop state

const state: import('../loop/state').LoopState = {

active: true,

sessionId,

loopName,

worktreeDir: worktreeDir ?? ctx.directory,

projectDir: ctx.directory,

worktreeBranch,

iteration: 1,

maxIterations,

startedAt: new Date().toISOString(),

prompt: planText,

phase: 'coding',

errorCount: 0,

auditCount: 0,

status: 'running',

worktree: true,

sandbox: sandboxEnabled,

sandboxContainer: sandboxContainer ?? undefined,

executionModel,

auditorModel,

executionVariant,

auditorVariant,

workspaceId,

hostSessionId: input.hostSessionId,

currentSectionIndex: 0,

totalSections: 0,

finalAuditDone: false,

}

deps.loop.setState(loopName, state)

deps.loop.registerLoopSession(sessionId, loopName)

deps.logger.log(`attachLoopToSession: state stored for loop=${loopName}`)

onStarted?.({

sessionId,

loopName,

displayName,

worktreeDir,

workspaceId,

})

// === Section extraction ===

const maxSections = 12

const sections = decomposeDeterministically(planText, { maxSections })

let promptText: string

if (sections.length > 0 && deps.sectionPlansRepo) {

deps.sectionPlansRepo.bulkInsert({ projectId: ctx.projectId, loopName, sections })

deps.loopsRepo.setTotalSections(ctx.projectId, loopName, sections.length)

deps.loopsRepo.setCurrentSectionIndex(ctx.projectId, loopName, 0)

deps.sectionPlansRepo.setStatus(ctx.projectId, loopName, 0, 'in_progress')

deps.sectionPlansRepo.setStartedAt(ctx.projectId, loopName, 0, Date.now())

const updatedState = { ...state, phase: 'coding' as const, currentSectionIndex: 0, totalSections: sections.length }

promptText = deps.loop.buildSectionInitialPrompt(updatedState as import('../loop/state').LoopState)

} else {

deps.loopsRepo.setTotalSections(ctx.projectId, loopName, 0)

promptText = planText

}

// Wait for sandbox readiness in worktree+sandbox mode (after persistence)

if (sandboxEnabled && deps.sandboxManager && deps.dataDir) {

const dbPath = join(deps.dataDir, 'forge.db')

if (existsSync(dbPath)) {

const { waitForSandboxReady } = await import('../utils/sandbox-ready')

const waitResult = await waitForSandboxReady({

projectId: ctx.projectId,

loopName,

dbPath,

pollMs: 200,

timeoutMs: 15_000,

})

if (!waitResult.ready) {

deps.logger.error(`attachLoopToSession: sandbox not ready (${waitResult.reason})`)

try {

const { createDockerService } = await import('../sandbox/docker')

const docker = createDockerService(deps.logger as unknown as Console)

const cn = docker.containerName(loopName)

if (await docker.isRunning(cn)) {

await docker.removeContainer(cn)

}

} catch (cleanupErr) {

deps.logger.error('attachLoopToSession: failed to remove sandbox container after timeout', cleanupErr)

}

deps.loop.deleteState(loopName)

return { ok: false, code: 'internal_error', message: `Sandbox not ready: ${waitResult.reason}` }

}

deps.logger.log(`attachLoopToSession: sandbox ready (${waitResult.containerName})`)

}

}

// Navigate TUI if requested with early timing

if (selectSession && selectSessionTiming === 'after-create') {

const selection = workspaceId

? { workspace: workspaceId, sessionID: sessionId }

: { sessionID: sessionId }

selectSessionWithFallback(deps, selection).catch((err: unknown) => {

deps.logger.error('attachLoopToSession: failed to navigate TUI (early)', err as Error)

})

}

if (!sendInitialPrompt) {

if (startWatchdog && deps.loopHandler) {

deps.loopHandler.startWatchdog(loopName)

}

deps.logger.log(`attachLoopToSession: attached loop=${loopName} without sending initial prompt`)

return { ok: true, loopName }

}

// Send initial prompt with fallback

const sessionDir = worktreeDir

const promptParts = [{ type: 'text' as const, text: promptText }]

const workspaceParam = workspaceId ? { workspace: workspaceId } : {}

let promptResult: { result: SessionPromptResult; usedModel?: typeof loopModel }

if (loopModel) {

promptResult = await retryWithModelFallback(

async () => {

markPromptSent(loopName, sessionId, deps.logger)

const { result } = await promptSessionWithFallback(

deps,

{

sessionID: sessionId,

directory: sessionDir,

parts: promptParts,

agent: 'code',

...workspaceParam,

},

loopModel,

)

return result

},

async () => {

markPromptSent(loopName, sessionId, deps.logger)

const { result } = await promptSessionWithFallback(

deps,

{

sessionID: sessionId,

directory: sessionDir,

parts: promptParts,

agent: 'code',

...workspaceParam,

},

undefined,

)

return result

},

loopModel,

deps.logger as unknown as Console,

)

} else {

markPromptSent(loopName, sessionId, deps.logger)

promptResult = await promptSessionWithFallback(

deps,

{

sessionID: sessionId,

directory: sessionDir,

parts: promptParts,

agent: 'code',

...workspaceParam,

},

loopModel,

)

}