orizu 0.5.47 → 0.5.49

package/src/hosted-boot.ts

@@ -197,6 +197,8 @@ export async function postBootStatus(opts: {
   status: 'ready' | 'failed' | 'complete' | 'turn_failed'
   runId: string | null
   reason?: string | null
+  /** ORI-2512: how long each boot step took, sent with `ready`. */
+  bootSteps?: readonly BootStep[]
   fetchImpl: BootFetch
   log?: (line: string) => void
 }): Promise<void> {
@@ -208,6 +210,7 @@ export async function postBootStatus(opts: {
         status: opts.status,
         ...(opts.runId ? { runId: opts.runId } : {}),
         ...(opts.reason ? { reason: opts.reason } : {}),
+        ...(opts.bootSteps?.length ? { bootSteps: opts.bootSteps } : {}),
       }),
     })
     opts.log?.(`boot-status ${opts.status} reported (${res.status})`)
@@ -216,9 +219,31 @@ export async function postBootStatus(opts: {
   }
 }
 
+/** ORI-2512: one step of the in-sandbox boot and how long it took. */
+interface BootStep {
+  step: string
+  ms: number
+}
+
+/** Times the boot's steps, each from the end of the one before. */
+function bootStepClock(now: () => number): { mark: (step: string) => void; steps: BootStep[] } {
+  const steps: BootStep[] = []
+  let last = now()
+  return {
+    steps,
+    mark: step => {
+      const at = now()
+      // Timing only describes the boot: a clock that goes back skips a step.
+      if (at >= last) steps.push({ step, ms: Math.round(at - last) })
+      last = at
+    },
+  }
+}
+
 async function postRequiredIdleReady(opts: {
   bootStatusUrl: string
   bootSecret: string
+  bootSteps: readonly BootStep[]
   fetchImpl: BootFetch
   sleep: (ms: number) => Promise<void>
   attemptTimeoutMs?: number
@@ -229,7 +254,7 @@ async function postRequiredIdleReady(opts: {
       const response = await opts.fetchImpl(opts.bootStatusUrl, {
         method: 'POST',
         headers: { Authorization: `Bearer ${opts.bootSecret}`, 'Content-Type': 'application/json' },
-        body: JSON.stringify({ status: 'ready' }),
+        body: JSON.stringify({ status: 'ready', ...(opts.bootSteps.length ? { bootSteps: opts.bootSteps } : {}) }),
         signal: AbortSignal.timeout(opts.attemptTimeoutMs ?? TURN_STATUS_ATTEMPT_TIMEOUT_MS),
       })
       if (response.ok) return
@@ -1015,6 +1040,7 @@ async function runHostedBootWithLive(
   delete processEnv.ORIZU_BOOT_SECRET
   processEnv.ORIZU_NO_UPDATE_CHECK = '1'
   if (env.runId) assertSafeRunId(env.runId)
+  const bootClock = bootStepClock(now)
 
   // 1 — Pull the agent bearer (retry/backoff — the DO may still be arming).
   let bearer = await pullAgentBearer({
@@ -1027,24 +1053,29 @@ async function runHostedBootWithLive(
     log,
   })
   log('agent bearer pulled')
+  bootClock.mark('boot_agent_token')
 
   // 2 — Pull the connector env bundle and export it (+ register redaction).
   const bundle = await fetchEnvBundle({ envBundleUrl: env.envBundleUrl, bearer: bearer.token, fetchImpl })
   const redacted = applyEnvBundle(bundle, processEnv)
   log(`env bundle applied (${bundle.connectors.length} connectors, ${redacted.length} redacted vars)`)
+  bootClock.mark('boot_env_bundle')
 
   // 3 — Resolve the session (workspace/branch/task) + run + repo from the plane.
   let session = await resolveSession({ baseUrl: env.baseUrl, sessionId: env.sessionId, bearer: bearer.token, fetchImpl })
   let currentNonTerminalRunId = session.runStatus === 'pending' || session.runStatus === 'running'
     ? session.runId
     : null
+  bootClock.mark('boot_session')
   // Production restarts with no live run are between turns. Prove this boot is
   // live before waiting so the coordinator's readiness timeout cannot reap an
   // intentionally idle sandbox before the longer hosted idle policy applies.
-  if (!opts.runLoop && !currentNonTerminalRunId) {
+  const bootsIdle = !opts.runLoop && !currentNonTerminalRunId
+  if (bootsIdle) {
     await postRequiredIdleReady({
       bootStatusUrl: env.bootStatusUrl,
       bootSecret: env.bootSecret,
+      bootSteps: bootClock.steps,
       fetchImpl,
       sleep,
       attemptTimeoutMs: turnStatusAttemptTimeoutMs,
@@ -1144,6 +1175,7 @@ async function runHostedBootWithLive(
   const repo = await resolveRepo({ baseUrl: env.baseUrl, workspaceId, sessionId: env.sessionId, bearer: bearer.token, fetchImpl })
   const repositoryHost = new URL(repo.cloneUrl).host.toLowerCase()
   log(`resolved run ${runId} on ${repo.repoFullName}@${session.repoBranch}`)
+  bootClock.mark('boot_repo')
 
   // 4 — Write the run-scoped assets: boot secret + initial bearer (0600), the
   // PULL-MODE credential helper + its boot context. The bearer file feeds the
@@ -1347,6 +1379,7 @@ const c = JSON.parse(fs.readFileSync(process.argv[2], 'utf8'));
   exec('git', ['-C', workspaceDir, 'config', 'user.name', AGENT_GIT_IDENTITY.name])
   exec('git', ['-C', workspaceDir, 'config', 'user.email', AGENT_GIT_IDENTITY.email])
   if (!wokenDisk && !sessionCopyFilled) log(`cloned ${session.repoBranch}`)
+  bootClock.mark('boot_clone')
 
   // 5a — ORI-2609: the team copy holds only the projects the team seed knew
   // about. Write this session's project folder if it is missing, before the
@@ -1359,6 +1392,7 @@ const c = JSON.parse(fs.readFileSync(process.argv[2], 'utf8'));
       project: { id: session.projectId, slug: session.projectSlug, name: session.projectName },
       exec: (cmd, args) => exec(cmd, args),
     }))
+  bootClock.mark('boot_project_folder')
 
   // 5b — Stage the orizu skill into the cloned repo so the agent discovers the
   // Orizu workflows (ALI-1059). SHARED with the operator path via `stageOrizuSkill`
@@ -1377,6 +1411,7 @@ const c = JSON.parse(fs.readFileSync(process.argv[2], 'utf8'));
   } catch (error) {
     log(`orizu skill staging failed: ${error instanceof Error ? error.message : String(error)}`)
   }
+  bootClock.mark('boot_skill_stage')
 
   // ALI-1060: the agent is now genuinely LIVE — bearer minted, connectors
   // applied, session/run resolved, repo cloned, skill staged. Signal the
@@ -1388,6 +1423,9 @@ const c = JSON.parse(fs.readFileSync(process.argv[2], 'utf8'));
     bootSecret: env.bootSecret,
     status: 'ready',
     runId,
+    // An idle boot sent its steps before it waited for work; the wait is not
+    // a boot step.
+    ...(bootsIdle ? {} : { bootSteps: bootClock.steps }),
     fetchImpl,
     log,
   })

package/src/hosted-optimization.ts

@@ -3,13 +3,12 @@ import { existsSync, readFileSync, rmSync } from 'node:fs'
 import { createServer } from 'node:http'
 import { tmpdir } from 'node:os'
 import { delimiter, join } from 'node:path'
-import { runPipedChild } from './child-output-tee.js'
 import { getGepaPythonPathEntries } from './gepa-python-paths.js'
 import { deliveredProviderLookup, HOSTED_PROVIDER_FAILURE, INJECTED_ENV_VARS_ENV, PROVIDER_REGISTRY_EXTRA_ENV } from './hosted-environment.js'
 import { credentialEnvFor, parseModelIdentity } from './provider-registry.js'
 import type { ProviderLookup } from './provider-lookup.js'
-import { materializeRunnerVersion, cleanupMaterializedRunners } from './runner-version-materialization.js'
 import { prepareSkilledProposerLaunch, spawnSkilledProposerChild } from './skilled-proposer-launch.js'
+import type { SkilledProposerStopOptions } from './skilled-proposer-launch.js'
 import { hostedProviderFromModel } from './hosted-provider-settings.js'
 import { validNormalizedSkilledProposerConfig } from './skilled-proposer-wire.js'
 import { REDACTION_PLACEHOLDER, redactSecrets } from './secret-redaction.js'
@@ -358,7 +357,8 @@ async function startTokenBroker(
   }
   return {
     url: `http://127.0.0.1:${address.port}/${nonce}`,
-    stop: () => { server.close() },
+    // Also drop open keep-alive connections, so no refresh succeeds after stop.
+    stop: () => { server.close(); server.closeAllConnections() },
     token: () => activeToken,
     secrets: () => [...tokens],
   }
@@ -367,30 +367,23 @@ async function spawnOfficial(
   python: string,
   environment: NodeJS.ProcessEnv,
   ready: () => Promise<void>,
-  output: ProcessOutputCapture
+  output: ProcessOutputCapture,
+  stopOptions: SkilledProposerStopOptions,
 ): Promise<{ status: number | null; error?: Error }> {
-  if (environment.ORIZU_CANDIDATE_PROPOSER === 'skilled-proposer') {
-    return spawnSkilledProposerChild(
-      python,
-      ['-m', 'orizu_gepa_connector'],
-      'official',
-      environment,
-      ready,
-      {
-        stdout: chunk => output.stdout.append(chunk),
-        stderr: chunk => output.stderr.append(chunk),
-      }
-    )
-  }
-  return runPipedChild(
+  // ORI-2429: both proposers start through the launcher (ORI-2402), so a stop
+  // signal reaches the optimizer, which then ends instead of outliving the
+  // CLI, and the CLI cleans up before it ends by that signal.
+  return spawnSkilledProposerChild(
     python,
     ['-m', 'orizu_gepa_connector'],
+    'official',
     environment,
     ready,
     {
       stdout: chunk => output.stdout.append(chunk),
       stderr: chunk => output.stderr.append(chunk),
-    }
+    },
+    stopOptions,
   )
 }
 async function ensureFailedRun(
@@ -430,7 +423,14 @@ export async function hostedOptimizationCommand(io: HostedOptimizationIo): Promi
   }
   delete process.env.ORIZU_BOOT_SECRET
   let reason = 'hosted_optimization_mint_refused'
-  const cleanups: Array<() => void> = []
+  // ORI-2429: one Effect scope owns the runner copies, the result file and the
+  // token broker, so a stop signal removes them too (see runner-folders.ts).
+  const { Effect, Scope } = await import('effect')
+  const { downloadedRunner, removeOnClose, RemovalLedger, stopClosesScope } = await import('./runner-folders.js')
+  const ledger = new RemovalLedger()
+  const { scope, close, stop, listen, removeHandlers } = stopClosesScope()
+  const inScope = <A>(effect: import('effect').Effect.Effect<A, unknown, import('effect').Scope.Scope>) =>
+    Effect.runPromise(effect.pipe(Effect.provideService(Scope.Scope, scope)))
   let broker: TokenBroker | undefined
   const resultFile = join(tmpdir(), `orizu-hosted-optimization-result-${boot.runId}-${randomUUID()}.json`)
   const diagnosticSecrets = () => injectedSecrets(boot, broker)
@@ -438,6 +438,7 @@ export async function hostedOptimizationCommand(io: HostedOptimizationIo): Promi
   const bootOutput = new BoundedTextCapture(diagnosticSecrets)
   let failureDiagnostics: FailureDiagnostics | undefined
   try {
+    listen()
     const first = await mint(boot)
     if (first.response.status === 422) reason = 'hosted_optimization_spec_missing'
     if (!first.response.ok) {
@@ -462,18 +463,28 @@ export async function hostedOptimizationCommand(io: HostedOptimizationIo): Promi
     process.env.ORIZU_BASE_URL = boot.baseUrl.origin
     process.env.ORIZU_TOKEN = minted.token
     reason = 'hosted_optimization_materialization_failed'
-    const candidate = await materializeRunnerVersion(String(minted.jobSpec.runnerVersionId)); cleanups.push(candidate.cleanup)
-    const scorer = await materializeRunnerVersion(String(minted.jobSpec.scorerRunnerVersionId)); cleanups.push(scorer.cleanup)
+    const candidate = await inScope(downloadedRunner(String(minted.jobSpec.runnerVersionId), ledger))
+    const scorer = await inScope(downloadedRunner(String(minted.jobSpec.scorerRunnerVersionId), ledger))
+    await inScope(removeOnClose(ledger, 'other', () => rmSync(resultFile, { force: true })))
     broker = await startTokenBroker(boot, minted)
+    const startedBroker = broker
+    await inScope(removeOnClose(ledger, 'other', () => startedBroker.stop()))
     const environment = childEnvironment(boot, minted, candidate.runnerDir, scorer.runnerDir, broker.url, resultFile)
     const launch = prepareSkilledProposerLaunch(process.env.PYTHON || 'python3', 'official', environment)
     reason = 'hosted_optimization_process_failed'
-    const result = await spawnOfficial(
-      launch.python,
-      launch.environment,
-      () => postBoot(boot, 'ready', { status: 'ready' }),
-      processOutput
-    )
+    stop.launcherOwnsStop()
+    let result: Awaited<ReturnType<typeof spawnOfficial>>
+    try {
+      result = await spawnOfficial(
+        launch.python,
+        launch.environment,
+        () => postBoot(boot, 'ready', { status: 'ready' }),
+        processOutput,
+        { beforeSignalExit: stop.beforeSignalExit },
+      )
+    } finally {
+      stop.launcherDone()
+    }
     if (result.error || result.status !== 0) {
       const processFailure = result.error?.message || `optimizer exited with status ${result.status}`
       const secrets = injectedSecrets(boot, broker)
@@ -506,8 +517,15 @@ export async function hostedOptimizationCommand(io: HostedOptimizationIo): Promi
     await io.printErr?.(reason)
     return 1
   } finally {
-    broker?.stop()
-    rmSync(resultFile, { force: true })
-    cleanupMaterializedRunners(cleanups)
+    removeHandlers()
+    // Closing stops the broker, deletes the result file and removes the copies.
+    close()
+    // As before: a broker or result-file failure is thrown first, then runner removals.
+    const otherFailure = ledger.failures.find(failure => failure.group === 'other')
+    if (otherFailure) throw otherFailure.error
+    const runnerFailures = ledger.failures.filter(failure => failure.group === 'downloads').map(failure => failure.error)
+    if (runnerFailures.length > 0) {
+        throw new AggregateError(runnerFailures, 'Failed to clean materialized runner directories')
+    }
   }
 }

package/src/hosted-runtime-assets.ts

@@ -51,15 +51,6 @@ export const AGENT_GIT_IDENTITY = { name: 'Orizu Agent', email: 'agent@orizu.ai'
 
 // -- Hosted task prompt scaffolding (ALI-1036) -------------------------------
 
-/**
- * Origin-specific standing preambles wrap hosted task prompts. Web sessions get
- * `HOSTED_TASK_PREAMBLE`, which directs the agent to use the question tool and
- * wait for the human. CLI-origin sessions get `HOSTED_TASK_PREAMBLE_CLI`, where
- * questions remain auto-answered for unattended operation. Undefined or unknown
- * origins fail safely to the CLI preamble. Both variants tell the agent to
- * commit as it goes; end-of-run auto-harvest (ALI-1036, `harvestWorkspace`)
- * preserves anything left uncommitted.
- */
 /** ORI-2653: where a push lands, shared by both preambles. A web session's
  * `origin` is its own copy of the team repository; a legacy GitHub session's
  * current branch is its session branch. Only an Orizu publish puts work on the
@@ -69,6 +60,15 @@ const HOSTED_PUSH_SCOPE =
   "not on the team's main. Never say work is published or on the team's main unless an Orizu " +
   'publish command reported that it merged or was already there. '
 
+/**
+ * Origin-specific standing preambles wrap hosted task prompts. Web sessions get
+ * `HOSTED_TASK_PREAMBLE`, which directs the agent to use the question tool and
+ * wait for the human. CLI-origin sessions get `HOSTED_TASK_PREAMBLE_CLI`, where
+ * questions remain auto-answered for unattended operation. Undefined or unknown
+ * origins fail safely to the CLI preamble. Both variants tell the agent to
+ * commit as it goes; end-of-run auto-harvest (ALI-1036, `harvestWorkspace`)
+ * preserves anything left uncommitted.
+ */
 export const HOSTED_TASK_PREAMBLE =
   'You are in a hosted sandbox. Work autonomously. When blocked on human input, call the built-in ' +
   'question tool with exactly one clear question and at most eight bounded options, then wait for ' +
@@ -76,6 +76,7 @@ export const HOSTED_TASK_PREAMBLE =
   'branch in logical units as you go (an automatic ' +
   'checkpoint will also save anything uncommitted at the end). Never switch branches. ' +
   HOSTED_PUSH_SCOPE +
+  "To put work on the team's main, run `orizu session publish`. " +
   'Production/default pointers and run metadata live in Orizu, not this repo.'
 
 /** Pre-ALI-1758 unattended behavior retained for CLI-originated sessions. */

package/src/index.ts

@@ -100,7 +100,6 @@ import {
   getTaskReport,
   updateTaskStatus,
 } from './task-commands.js'
-import { cleanupAll, throwWithCleanup } from './cleanup.js'
 import {
   extractFlagValue,
   verifyGepaRunnerDirsFromArgs,
@@ -177,7 +176,6 @@ import { inspectExistingWorkspaceTeam, getWorkspaceRoot } from './workspace.js'
 import { writeLastErrorRecord, extractLastErrorCode } from './last-error-record.js'
 import type { CliLengthStats, CliLengthMeasurementUnavailableReason } from './prompt-length-wire.js'
 import type { RunnerInstructionSet } from './runner-instruction-set-contract.js'
-import type { GepaVerifiedArgs } from './runner-dir-verify.js'
 import type { ReportCommentsCliContext } from './report-comments-cli.js'
 
 
@@ -1293,101 +1291,94 @@ const GEPA_RUNNER_MATERIALIZATION_PAIRS = [
   { versionFlag: '--scorer-runner-version-id', dirFlag: '--scorer-runner-dir' },
 ] as const
 
-async function materializeMissingGepaRunnerDirs(args: string[]): Promise<{
-  args: string[]
-  cleanup: () => void
-}> {
-  const rewritten = [...args]
-  const cleanups: Array<() => void> = []
-  const cleanup = () => cleanupAll(
-    cleanups,
-    'Failed to clean materialized runner directories'
-  )
-
-  try {
-    for (const pair of GEPA_RUNNER_MATERIALIZATION_PAIRS) {
-      const runnerVersionId = extractFlagValue(rewritten, pair.versionFlag)
-      const runnerDir = extractFlagValue(rewritten, pair.dirFlag)
-      if (!runnerVersionId || runnerDir) continue
-
-      const materialized = await materializeRunnerVersion(runnerVersionId)
-      cleanups.push(materialized.cleanup)
-      rewritten.push(pair.dirFlag, materialized.runnerDir)
-    }
-  } catch (error) {
-    throwWithCleanup(
-      error,
-      cleanups,
-      'Runner materialization failed and cleanup also failed'
-    )
-  }
-
-  return { args: rewritten, cleanup }
-}
-
 async function runGepaOptimization() {
   const project = getArg('--project') || await resolveProjectSlug(null)
   const baseUrl = getBaseUrl()
   const runGepa = getGepaPythonCommand(cliArgs.slice(2), process.env)
   const python = runGepa.python
-  let forwardedArgs = runGepa.args
-  // ALI-1159 (ADR-007): GEPA executes ad-hoc local runner dirs while
-  // attributing records to registered runner version ids — verify the bytes
-  // ARE those versions before the optimizer spawns. Scans the forwarded argv
-  // itself (both argparse flag forms), fail-closed on half-populated pairs,
-  // and REWRITES the dir flags to verified snapshots (the exact hashed bytes)
-  // so a post-hash mutation of the original dirs cannot change what runs.
-  const materialized = await materializeMissingGepaRunnerDirs(forwardedArgs)
-  let verified: GepaVerifiedArgs | undefined
+  // ORI-2429: one Effect scope owns every runner copy this run writes to the
+  // temp folder; it removes them on success, failure and stop signals.
+  const { Effect } = await import('effect')
+  const { downloadedRunner, heldUntilClose, RemovalLedger, runStoppable } = await import('./runner-folders.js')
+  const ledger = new RemovalLedger()
+  // Which step failed decides the message when a removal also failed, as before.
+  let phase: 'materialize' | 'launch' = 'materialize'
   let selectedEngine = 'official'
+  let failure: { error: unknown } | undefined
   try {
-    verified = await verifyGepaRunnerDirsFromArgs(materialized.args)
-    forwardedArgs = verified.args
-    // Uniform resolution (ALI-1090): honors ORIZU_TOKEN / ORIZU_TOKEN_FILE before
-    // credentials.json so hosted sandboxes can run optimizations. Read at spawn
-    // time — AFTER the verification awaits above, so a hosted token-file
-    // rotation crossing the hash + lookup round-trips cannot hand the child a
-    // stale bearer.
-    const token = resolveAuthTokenForBaseUrl(baseUrl)
-    if (!forwardedArgs.includes('--project')) {
-      forwardedArgs = ['--project', project, ...forwardedArgs]
-    }
-    const dispatch = applyHostedInstructionSetProfileOverride(dispatchGepaEngine(forwardedArgs, project, {
-      ...process.env,
-      ORIZU_API_URL: baseUrl,
-      ORIZU_TOKEN: token,
-      ORIZU_PROJECT: project,
-      ORIZU_VERIFIED_RUNNER_DIRS: JSON.stringify(verified.verifiedDirs),
-      PYTHONPATH: getGepaPythonPathEntries(process.env.PYTHONPATH).join(delimiter),
-      PYTHONUNBUFFERED: process.env.PYTHONUNBUFFERED || '1',
+    await runStoppable(stop => Effect.gen(function* () {
+      // Download registered runner versions passed without a local folder; the
+      // verification below then checks those bytes like any local folder.
+      const materializedArgs = [...runGepa.args]
+      for (const pair of GEPA_RUNNER_MATERIALIZATION_PAIRS) {
+        const runnerVersionId = extractFlagValue(materializedArgs, pair.versionFlag)
+        const runnerDir = extractFlagValue(materializedArgs, pair.dirFlag)
+        if (!runnerVersionId || runnerDir) continue
+        const materialized = yield* downloadedRunner(runnerVersionId, ledger, false)
+        materializedArgs.push(pair.dirFlag, materialized.runnerDir)
+      }
+      phase = 'launch'
+      // ALI-1159 (ADR-007): GEPA executes ad-hoc local runner dirs while
+      // attributing records to registered runner version ids — verify the bytes
+      // ARE those versions before the optimizer spawns. Scans the forwarded argv
+      // itself (both argparse flag forms), fail-closed on half-populated pairs,
+      // and REWRITES the dir flags to verified snapshots (the exact hashed bytes)
+      // so a post-hash mutation of the original dirs cannot change what runs.
+      const verified = yield* heldUntilClose(ledger, 'snapshots', () => verifyGepaRunnerDirsFromArgs(materializedArgs))
+      let forwardedArgs = verified.args
+      // Uniform resolution (ALI-1090): honors ORIZU_TOKEN / ORIZU_TOKEN_FILE before
+      // credentials.json so hosted sandboxes can run optimizations. Read at spawn
+      // time — AFTER the verification awaits above, so a hosted token-file
+      // rotation crossing the hash + lookup round-trips cannot hand the child a
+      // stale bearer.
+      const token = resolveAuthTokenForBaseUrl(baseUrl)
+      if (!forwardedArgs.includes('--project')) {
+        forwardedArgs = ['--project', project, ...forwardedArgs]
+      }
+      const dispatch = applyHostedInstructionSetProfileOverride(dispatchGepaEngine(forwardedArgs, project, {
+        ...process.env,
+        ORIZU_API_URL: baseUrl,
+        ORIZU_TOKEN: token,
+        ORIZU_PROJECT: project,
+        ORIZU_VERIFIED_RUNNER_DIRS: JSON.stringify(verified.verifiedDirs),
+        PYTHONPATH: getGepaPythonPathEntries(process.env.PYTHONPATH).join(delimiter),
+        PYTHONUNBUFFERED: process.env.PYTHONUNBUFFERED || '1',
+      }))
+      const instructionSetProfileVersionId = yield* Effect.tryPromise({
+        try: () => resolveGepaSeedFromEnvironment(dispatch.environment, project, 'production'),
+        catch: error => error,
+      })
+      if (instructionSetProfileVersionId) dispatch.environment.ORIZU_INSTRUCTION_SET_PROFILE_VERSION_ID = instructionSetProfileVersionId
+      selectedEngine = dispatch.engine
+      const launch = prepareSkilledProposerLaunch(python, dispatch.engine, dispatch.environment)
+      // While the optimizer runs, the launcher owns stop signals (ORI-2402) and
+      // closes this scope just before the CLI ends by the signal. Taken in the
+      // same step as the launch, so no stop can fall between the two.
+      const result = yield* Effect.tryPromise({
+        try: () => (stop.launcherOwnsStop(), spawnSkilledProposerChild(
+          launch.python, ['-m', dispatch.module, ...dispatch.args], dispatch.engine, launch.environment,
+          undefined, undefined, { beforeSignalExit: stop.beforeSignalExit },
+        )),
+        catch: error => error,
+      }).pipe(Effect.ensuring(Effect.sync(stop.launcherDone)))
+      if (result.error) {
+        return yield* Effect.fail(new Error(`${selectedEngine} GEPA engine failed: ${result.error.message}`, { cause: result.error }))
+      }
+      if (result.status !== 0) {
+        return yield* Effect.fail(new Error(`${selectedEngine} GEPA engine failed with exit code ${result.status}`))
+      }
     }))
-    const instructionSetProfileVersionId = await resolveGepaSeedFromEnvironment(dispatch.environment, project, 'production')
-    if (instructionSetProfileVersionId) dispatch.environment.ORIZU_INSTRUCTION_SET_PROFILE_VERSION_ID = instructionSetProfileVersionId
-    selectedEngine = dispatch.engine
-    const launch = prepareSkilledProposerLaunch(python, dispatch.engine, dispatch.environment)
-    const result = await spawnSkilledProposerChild(
-      launch.python, ['-m', dispatch.module, ...dispatch.args], dispatch.engine, launch.environment,
-    )
-    if (result.error) {
-      throw new Error(`${selectedEngine} GEPA engine failed: ${result.error.message}`, { cause: result.error })
-    }
-    if (result.status !== 0) {
-      throw new Error(`${selectedEngine} GEPA engine failed with exit code ${result.status}`)
-    }
   } catch (error) {
-    throwWithCleanup(
-      error,
-      [
-        ...(verified ? [verified.cleanup] : []),
-        materialized.cleanup,
-      ],
-      'GEPA launch failed and runner cleanup also failed'
-    )
+    failure = { error }
   }
-  cleanupAll(
-    [verified.cleanup, materialized.cleanup],
-    'Failed to clean GEPA runner directories'
-  )
+  // The scope has closed here; a removal failure decides the message, as before.
+  if (ledger.has()) {
+    if (!failure) throw new AggregateError(ledger.errors(), 'Failed to clean GEPA runner directories')
+    throw new AggregateError([failure.error, ...ledger.errors()], phase === 'materialize'
+      ? 'Runner materialization failed and cleanup also failed'
+      : 'GEPA launch failed and runner cleanup also failed')
+  }
+  if (failure) throw failure.error
   if (hasJsonFlag()) {
     printJson({ status: 'completed', exitCode: 0 })
   }
@@ -2256,6 +2247,7 @@ function isCliEntrypoint(): boolean {
 if (isCliEntrypoint()) {
   const rawArgs = process.argv.slice(2)
   withPassiveUpdateNotice(rawArgs, getCliVersion, printError, args =>
+    // ORI-2429: the process-boundary adapter stays a Promise (ADR-038 guide); the record write is Effect-owned and never replaces this error.
     main(args).catch(async error => {
       const message = error instanceof Error ? error.message : 'Unknown error'
       // The reporter email is unknown on the failure path, so the record masks every address.