orizu 0.5.48 → 0.5.49

package/dist/hosted-optimization.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hosted-optimization.d.ts","sourceRoot":"","sources":["../src/hosted-optimization.ts"],"names":[],"mappings":"AAeA,UAAU,oBAAoB;IAAG,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE;AAsZrF,wBAAsB,yBAAyB,CAAC,EAAE,EAAE,oBAAoB,GAAG,OAAO,CAAC,MAAM,CAAC,CA2FzF"}
+{"version":3,"file":"hosted-optimization.d.ts","sourceRoot":"","sources":["../src/hosted-optimization.ts"],"names":[],"mappings":"AAcA,UAAU,oBAAoB;IAAG,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE;AAgZrF,wBAAsB,yBAAyB,CAAC,EAAE,EAAE,oBAAoB,GAAG,OAAO,CAAC,MAAM,CAAC,CAoHzF"}

package/dist/hosted-optimization.js

@@ -3,11 +3,9 @@ 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 { materializeRunnerVersion, cleanupMaterializedRunners } from './runner-version-materialization.js';
 import { prepareSkilledProposerLaunch, spawnSkilledProposerChild } from './skilled-proposer-launch.js';
 import { hostedProviderFromModel } from './hosted-provider-settings.js';
 import { validNormalizedSkilledProposerConfig } from './skilled-proposer-wire.js';
@@ -331,22 +329,20 @@ async function startTokenBroker(boot, initial) {
     }
     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],
     };
 }
-async function spawnOfficial(python, environment, ready, output) {
-    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(python, ['-m', 'orizu_gepa_connector'], environment, ready, {
+async function spawnOfficial(python, environment, ready, output, stopOptions) {
+    // 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(boot, token, engineError, diagnostics) {
     const headers = { authorization: `Bearer ${token}`, 'content-type': 'application/json' };
@@ -385,7 +381,13 @@ export async function hostedOptimizationCommand(io) {
     }
     delete process.env.ORIZU_BOOT_SECRET;
     let reason = 'hosted_optimization_mint_refused';
-    const cleanups = [];
+    // 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 = (effect) => Effect.runPromise(effect.pipe(Effect.provideService(Scope.Scope, scope)));
     let broker;
     const resultFile = join(tmpdir(), `orizu-hosted-optimization-result-${boot.runId}-${randomUUID()}.json`);
     const diagnosticSecrets = () => injectedSecrets(boot, broker);
@@ -393,6 +395,7 @@ export async function hostedOptimizationCommand(io) {
     const bootOutput = new BoundedTextCapture(diagnosticSecrets);
     let failureDiagnostics;
     try {
+        listen();
         const first = await mint(boot);
         if (first.response.status === 422)
             reason = 'hosted_optimization_spec_missing';
@@ -416,15 +419,23 @@ export async function hostedOptimizationCommand(io) {
         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;
+        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);
@@ -459,8 +470,16 @@ export async function hostedOptimizationCommand(io) {
         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/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAwLA,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAA;AAEhE,eAAO,MAAM,wBAAwB,GAAI,iBAAiB,MAAM;;;EACJ,CAAA;AAE5D,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AAC5E,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AAstCtD,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CA0B1G;AAED,eAAO,MAAM,iBAAiB,SAAU,CAAA;AACxC,eAAO,MAAM,uBAAuB,QAAkB,CAAA;AACtD,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,iBAAiB,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,UAAU,CAexH;AAmMD,wBAAsB,IAAI,CAAC,OAAO,WAAwB,iBAiiBzD;AA6DD,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAA;AAEhF,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAsLA,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAA;AAEhE,eAAO,MAAM,wBAAwB,GAAI,iBAAiB,MAAM;;;EACJ,CAAA;AAE5D,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AAC5E,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AA+sCtD,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CA0B1G;AAED,eAAO,MAAM,iBAAiB,SAAU,CAAA;AACxC,eAAO,MAAM,uBAAuB,QAAkB,CAAA;AACtD,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,iBAAiB,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,UAAU,CAexH;AAmMD,wBAAsB,IAAI,CAAC,OAAO,WAAwB,iBAiiBzD;AA8DD,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAA;AAEhF,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA"}

package/dist/index.js

@@ -24,7 +24,6 @@ import { readMarkdownReportInput } from './markdown-report-input.js';
 import { pushPromptDraft } from './prompt-draft-push.js';
 import { promptPushErrorMessage, promptReportCommand } from './prompt-report-cli.js';
 import { parseCommaSeparated, listTasks, createTask, updateTask, discardTask, publishTask, assignTask, taskStatus, setTaskReport, getTaskReport, updateTaskStatus, } from './task-commands.js';
-import { cleanupAll, throwWithCleanup } from './cleanup.js';
 import { extractFlagValue, verifyGepaRunnerDirsFromArgs, verifyRunnerDirRegistered, assertSnapshotManifestConfined, } from './runner-dir-verify.js';
 import { getGepaPythonCommand } from './gepa-python-command.js';
 import { resolveAuthTokenForBaseUrl } from './credentials.js';
@@ -941,82 +940,96 @@ const GEPA_RUNNER_MATERIALIZATION_PAIRS = [
     { versionFlag: '--runner-version-id', dirFlag: '--candidate-runner-dir' },
     { versionFlag: '--scorer-runner-version-id', dirFlag: '--scorer-runner-dir' },
 ];
-async function materializeMissingGepaRunnerDirs(args) {
-    const rewritten = [...args];
-    const cleanups = [];
-    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;
+    // 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';
     let selectedEngine = 'official';
+    let failure;
     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');
-    }
-    cleanupAll([verified.cleanup, materialized.cleanup], 'Failed to clean GEPA runner directories');
+        failure = { error };
+    }
+    // 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 });
     }
@@ -1794,7 +1807,9 @@ function isCliEntrypoint() {
 }
 if (isCliEntrypoint()) {
     const rawArgs = process.argv.slice(2);
-    withPassiveUpdateNotice(rawArgs, getCliVersion, printError, args => main(args).catch(async (error) => {
+    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.
         await writeLastErrorRecord({

package/dist/runner-folders.d.ts

@@ -0,0 +1,61 @@
+import { Effect, Scope } from 'effect';
+export type RemovalGroup = 'downloads' | 'snapshots' | 'other';
+/** Removal failures seen while a scope closes; Effect finalizers cannot fail. */
+export declare class RemovalLedger {
+    readonly failures: {
+        group: RemovalGroup;
+        error: unknown;
+    }[];
+    has(group?: RemovalGroup): boolean;
+    errors(): unknown[];
+}
+/** Remove with `remove` when the surrounding scope closes, recording a failure. */
+export declare function removeOnClose(ledger: RemovalLedger, group: RemovalGroup, remove: () => void): Effect.Effect<void, never, Scope.Scope>;
+/**
+ * Download a registered runner version into a private temp folder that the
+ * caller's scope removes. A stop mid-download aborts the transfer and still
+ * removes the folder. Messages match the previous Promise implementation.
+ */
+export declare function downloadedRunner(runnerVersionId: string, ledger: RemovalLedger, verifyRegisteredDigest?: boolean): Effect.Effect<{
+    runnerDir: string;
+    remove: () => void;
+}, unknown, Scope.Scope>;
+/** A Promise-returning resource (acquired whole) whose cleanup the scope runs. */
+export declare function heldUntilClose<A extends {
+    cleanup: () => void;
+}>(ledger: RemovalLedger, group: RemovalGroup, acquire: () => Promise<A>): Effect.Effect<A, unknown, Scope.Scope>;
+export interface StopControl {
+    /** Hand stop signals to the optimizer launcher; pass this as its beforeSignalExit. */
+    readonly beforeSignalExit: () => Promise<void> | void;
+    readonly launcherOwnsStop: () => void;
+    readonly launcherDone: () => void;
+}
+/**
+ * Run `program` in a scope that removes the runner copies however it ends.
+ * Before the optimizer starts, a stop signal interrupts the program (the scope
+ * closes as it unwinds) and the CLI then ends by that signal. While the
+ * launcher runs the optimizer, the launcher owns the signal and calls
+ * `beforeSignalExit`, which closes the scope synchronously: the removal then
+ * finishes even when the optimizer used up the whole stop cap.
+ */
+export declare function runStoppable<A>(program: (stop: StopControl) => Effect.Effect<A, unknown, Scope.Scope>): Promise<A>;
+/**
+ * For a workflow that stays a Promise (hosted optimization): a scope that a
+ * stop signal closes before the CLI ends by that signal. Before the optimizer
+ * starts our handlers do it; while the launcher runs it, the launcher calls
+ * `stop.beforeSignalExit`. Closing aborts an in-flight download and removes
+ * every registered file, folder and server; the finalizers are synchronous.
+ */
+export declare function stopClosesScope(): {
+    scope: Scope.Closeable;
+    close: () => void;
+    stop: StopControl;
+    listen: () => void;
+    removeHandlers: () => void;
+};
+/** Open a scope for an adapter that must hand back a synchronous cleanup. */
+export declare function openScope(): {
+    scope: Scope.Closeable;
+    close: () => void;
+};
+//# sourceMappingURL=runner-folders.d.ts.map

package/dist/runner-folders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner-folders.d.ts","sourceRoot":"","sources":["../src/runner-folders.ts"],"names":[],"mappings":"AAIA,OAAO,EAAS,MAAM,EAAe,KAAK,EAAE,MAAM,QAAQ,CAAA;AAY1D,MAAM,MAAM,YAAY,GAAG,WAAW,GAAG,WAAW,GAAG,OAAO,CAAA;AAE9D,iFAAiF;AACjF,qBAAa,aAAa;IACxB,QAAQ,CAAC,QAAQ,EAAE;QAAE,KAAK,EAAE,YAAY,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,EAAE,CAAK;IACjE,GAAG,CAAC,KAAK,CAAC,EAAE,YAAY,GAAG,OAAO;IAGlC,MAAM,IAAI,OAAO,EAAE;CAGpB;AAED,mFAAmF;AACnF,wBAAgB,aAAa,CAAC,MAAM,EAAE,aAAa,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,IAAI,2CAI3F;AAaD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,eAAe,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,sBAAsB,UAAO;;;yBAgD7G;AAED,kFAAkF;AAClF,wBAAgB,cAAc,CAAC,CAAC,SAAS;IAAE,OAAO,EAAE,MAAM,IAAI,CAAA;CAAE,EAAE,MAAM,EAAE,aAAa,EAAE,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,0CAStI;AAMD,MAAM,WAAW,WAAW;IAC1B,sFAAsF;IACtF,QAAQ,CAAC,gBAAgB,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IACrD,QAAQ,CAAC,gBAAgB,EAAE,MAAM,IAAI,CAAA;IACrC,QAAQ,CAAC,YAAY,EAAE,MAAM,IAAI,CAAA;CAClC;AAED;;;;;;;GAOG;AACH,wBAAsB,YAAY,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CA2CxH;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe;;;;;;EAuB9B;AAED,6EAA6E;AAC7E,wBAAgB,SAAS;;;EAWxB"}

package/dist/runner-folders.js

@@ -0,0 +1,222 @@
+import { createHash } from 'node:crypto';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { Cause, Effect, Exit, Fiber, Scope } from 'effect';
+import { ARTIFACT_MAX_BYTES } from './artifact-pull.js';
+import { authedFetch } from './http.js';
+import { unzipRunnerArchive } from './runner-version-materialization.js';
+/** Removal failures seen while a scope closes; Effect finalizers cannot fail. */
+export class RemovalLedger {
+    failures = [];
+    has(group) {
+        return this.failures.some(failure => !group || failure.group === group);
+    }
+    errors() {
+        return this.failures.map(failure => failure.error);
+    }
+}
+/** Remove with `remove` when the surrounding scope closes, recording a failure. */
+export function removeOnClose(ledger, group, remove) {
+    return Effect.addFinalizer(() => Effect.sync(() => {
+        try {
+            remove();
+        }
+        catch (error) {
+            ledger.failures.push({ group, error });
+        }
+    }));
+}
+function request(path, signal) {
+    return Effect.tryPromise({
+        try: requestSignal => authedFetch(path, { signal: AbortSignal.any([requestSignal, signal]) }),
+        catch: error => error,
+    });
+}
+function text(response) {
+    return Effect.tryPromise({ try: () => response.text(), catch: error => error });
+}
+/**
+ * Download a registered runner version into a private temp folder that the
+ * caller's scope removes. A stop mid-download aborts the transfer and still
+ * removes the folder. Messages match the previous Promise implementation.
+ */
+export function downloadedRunner(runnerVersionId, ledger, verifyRegisteredDigest = true) {
+    return Effect.gen(function* () {
+        // Aborting on close also ends a body still streaming when a stop arrives.
+        const controller = yield* Effect.acquireRelease(Effect.sync(() => new AbortController()), controller => Effect.sync(() => controller.abort()));
+        let contentSha256;
+        if (verifyRegisteredDigest) {
+            const detailResponse = yield* request(`/api/cli/runner-versions/${encodeURIComponent(runnerVersionId)}`, controller.signal);
+            if (!detailResponse.ok)
+                return yield* Effect.fail(new Error(`Failed to resolve runner version: ${yield* text(detailResponse)}`));
+            const detail = (yield* Effect.tryPromise({ try: () => detailResponse.json(), catch: error => error }));
+            if (detail.runnerVersionId !== runnerVersionId || detail.status !== 'sealed'
+                || typeof detail.contentSha256 !== 'string' || !/^[0-9a-f]{64}$/u.test(detail.contentSha256)) {
+                return yield* Effect.fail(new Error('Runner version detail is invalid'));
+            }
+            contentSha256 = detail.contentSha256;
+        }
+        const response = yield* request(`/api/cli/runner-versions/${encodeURIComponent(runnerVersionId)}/download`, controller.signal);
+        if (!response.ok)
+            return yield* Effect.fail(new Error(`Failed to download runner version: ${yield* text(response)}`));
+        // The previous implementation removed the folder as soon as this runner
+        // failed, naming the runner when that removal failed too. Keep both.
+        let removed = false;
+        let tempDir = '';
+        const remove = () => { if (!removed) {
+            removed = true;
+            rmSync(tempDir, { recursive: true, force: true });
+        } };
+        // Created and registered for removal in one uninterruptible step.
+        yield* Effect.acquireRelease(Effect.sync(() => { tempDir = mkdtempSync(join(tmpdir(), 'orizu-runner-version-')); }), () => Effect.sync(() => {
+            try {
+                remove();
+            }
+            catch (error) {
+                ledger.failures.push({ group: 'downloads', error });
+            }
+        }));
+        return yield* Effect.gen(function* () {
+            const zipBytes = new Uint8Array(yield* Effect.tryPromise({ try: () => response.arrayBuffer(), catch: error => error }));
+            if (zipBytes.byteLength > ARTIFACT_MAX_BYTES)
+                return yield* Effect.fail(new Error(`Runner artifact exceeds ${ARTIFACT_MAX_BYTES} bytes`));
+            if (contentSha256 && createHash('sha256').update(zipBytes).digest('hex') !== contentSha256) {
+                return yield* Effect.fail(new Error('Runner artifact digest mismatch'));
+            }
+            const zipPath = join(tempDir, 'runner.zip'), runnerDir = join(tempDir, 'runner');
+            yield* Effect.try({ try: () => { writeFileSync(zipPath, zipBytes); unzipRunnerArchive(zipPath, runnerDir); }, catch: error => error });
+            return { runnerDir, remove };
+        }).pipe(Effect.catch(error => Effect.suspend(() => {
+            try {
+                remove();
+            }
+            catch (cleanupError) {
+                return Effect.fail(new AggregateError([error, cleanupError], `Runner ${runnerVersionId} materialization failed and cleanup also failed`));
+            }
+            return Effect.fail(error);
+        })));
+    });
+}
+/** A Promise-returning resource (acquired whole) whose cleanup the scope runs. */
+export function heldUntilClose(ledger, group, acquire) {
+    // Acquiring stays uninterruptible: a stop waits for it to finish, so a
+    // half-created snapshot is never orphaned; the scope then removes it.
+    return Effect.acquireRelease(Effect.tryPromise({ try: acquire, catch: error => error }), resource => Effect.sync(() => {
+        try {
+            resource.cleanup();
+        }
+        catch (error) {
+            ledger.failures.push({ group, error });
+        }
+    }));
+}
+const STOP_SIGNALS = ['SIGINT', 'SIGTERM', 'SIGHUP', 'SIGQUIT'];
+// Matches the launcher's stop cap (ORI-2402): a stop never waits longer.
+const STOP_CLEANUP_WAIT_MS = 15_000;
+/**
+ * Run `program` in a scope that removes the runner copies however it ends.
+ * Before the optimizer starts, a stop signal interrupts the program (the scope
+ * closes as it unwinds) and the CLI then ends by that signal. While the
+ * launcher runs the optimizer, the launcher owns the signal and calls
+ * `beforeSignalExit`, which closes the scope synchronously: the removal then
+ * finishes even when the optimizer used up the whole stop cap.
+ */
+export async function runStoppable(program) {
+    const { scope, close } = openScope();
+    let launcherOwned = false;
+    let stopping = false;
+    // eslint-disable-next-line prefer-const -- assigned after the handlers that read it
+    let fiber;
+    const interrupt = () => Effect.runPromise(Fiber.interrupt(fiber));
+    const removeHandlers = () => { for (const entry of handlers)
+        process.off(entry.signal, entry.handle); };
+    const handlers = STOP_SIGNALS.map(signal => ({
+        signal,
+        handle: () => {
+            if (launcherOwned || stopping)
+                return;
+            stopping = true;
+            let timer;
+            const expired = new Promise(resolve => { timer = setTimeout(resolve, STOP_CLEANUP_WAIT_MS); });
+            void Promise.race([interrupt(), expired]).finally(() => {
+                clearTimeout(timer);
+                removeHandlers();
+                process.kill(process.pid, signal);
+            });
+        },
+    }));
+    const control = {
+        beforeSignalExit: () => {
+            stopping = true;
+            // The launcher re-sends the signal next; none of ours may catch it.
+            removeHandlers();
+            close();
+        },
+        launcherOwnsStop: () => { launcherOwned = true; },
+        launcherDone: () => { launcherOwned = false; },
+    };
+    for (const entry of handlers)
+        process.on(entry.signal, entry.handle);
+    fiber = Effect.runFork(Scope.provide(scope)(program(control)).pipe(Effect.ensuring(Effect.sync(close))));
+    try {
+        const exit = await Effect.runPromise(Effect.exit(Fiber.join(fiber)));
+        // A stop ends the process by its signal; nothing more to report here.
+        if (stopping)
+            return await new Promise(() => { });
+        if (Exit.isSuccess(exit))
+            return exit.value;
+        throw Cause.squash(exit.cause);
+    }
+    finally {
+        removeHandlers();
+    }
+}
+/**
+ * For a workflow that stays a Promise (hosted optimization): a scope that a
+ * stop signal closes before the CLI ends by that signal. Before the optimizer
+ * starts our handlers do it; while the launcher runs it, the launcher calls
+ * `stop.beforeSignalExit`. Closing aborts an in-flight download and removes
+ * every registered file, folder and server; the finalizers are synchronous.
+ */
+export function stopClosesScope() {
+    const { scope, close } = openScope();
+    let launcherOwned = false;
+    let stopping = false;
+    const removeHandlers = () => { for (const entry of handlers)
+        process.off(entry.signal, entry.handle); };
+    const handlers = STOP_SIGNALS.map(signal => ({
+        signal,
+        handle: () => {
+            if (launcherOwned || stopping)
+                return;
+            stopping = true;
+            close();
+            removeHandlers();
+            process.kill(process.pid, signal);
+        },
+    }));
+    // Installed by the caller inside its try, so a setup throw cannot leave them behind.
+    const listen = () => { for (const entry of handlers)
+        process.on(entry.signal, entry.handle); };
+    const stop = {
+        beforeSignalExit: () => { stopping = true; removeHandlers(); close(); },
+        launcherOwnsStop: () => { launcherOwned = true; },
+        launcherDone: () => { launcherOwned = false; },
+    };
+    return { scope, close, stop, listen, removeHandlers };
+}
+/** Open a scope for an adapter that must hand back a synchronous cleanup. */
+export function openScope() {
+    const scope = Scope.makeUnsafe();
+    let closed = false;
+    return {
+        scope,
+        close: () => {
+            if (closed)
+                return;
+            closed = true;
+            Effect.runSync(Scope.close(scope, Exit.void));
+        },
+    };
+}

package/dist/runner-version-materialization.d.ts

@@ -1,6 +1,6 @@
+export declare function unzipRunnerArchive(zipPath: string, runnerDir: string): void;
 export declare function materializeRunnerVersion(runnerVersionId: string, verifyRegisteredDigest?: boolean): Promise<{
     runnerDir: string;
     cleanup: () => void;
 }>;
-export declare function cleanupMaterializedRunners(cleanups: Array<() => void>): void;
 //# sourceMappingURL=runner-version-materialization.d.ts.map

package/dist/runner-version-materialization.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runner-version-materialization.d.ts","sourceRoot":"","sources":["../src/runner-version-materialization.ts"],"names":[],"mappings":"AAuBA,wBAAsB,wBAAwB,CAAC,eAAe,EAAE,MAAM,EAAE,sBAAsB,UAAO,GAAG,OAAO,CAAC;IAC9G,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,IAAI,CAAA;CACvC,CAAC,CA2BD;AACD,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAE5E"}
+{"version":3,"file":"runner-version-materialization.d.ts","sourceRoot":"","sources":["../src/runner-version-materialization.ts"],"names":[],"mappings":"AAEA,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAa3E;AACD,wBAAsB,wBAAwB,CAAC,eAAe,EAAE,MAAM,EAAE,sBAAsB,UAAO,GAAG,OAAO,CAAC;IAC9G,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,IAAI,CAAA;CACvC,CAAC,CAwBD"}