orizu 0.5.47 → 0.5.49

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"}

package/dist/runner-version-materialization.js

@@ -1,13 +1,6 @@
-import { createHash } from 'node:crypto';
 import { spawnSync } from 'node:child_process';
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { ARTIFACT_MAX_BYTES } from './artifact-pull.js';
-import { cleanupAll, throwWithCleanup } from './cleanup.js';
-import { authedFetch } from './http.js';
 import { sanitizeTerminalText } from './json-response.js';
-function unzip(zipPath, runnerDir) {
+export function unzipRunnerArchive(zipPath, runnerDir) {
     const listing = spawnSync('unzip', ['-Z1', zipPath], { encoding: 'utf8' });
     if (listing.error)
         throw listing.error;
@@ -27,38 +20,27 @@ function unzip(zipPath, runnerDir) {
         throw new Error(`unzip failed: ${sanitizeTerminalText(result.stderr || result.stdout || '')}`);
 }
 export async function materializeRunnerVersion(runnerVersionId, verifyRegisteredDigest = true) {
-    let contentSha256;
-    if (verifyRegisteredDigest) {
-        const detailResponse = await authedFetch(`/api/cli/runner-versions/${encodeURIComponent(runnerVersionId)}`);
-        if (!detailResponse.ok)
-            throw new Error(`Failed to resolve runner version: ${await detailResponse.text()}`);
-        const detail = await detailResponse.json();
-        if (detail.runnerVersionId !== runnerVersionId || detail.status !== 'sealed'
-            || typeof detail.contentSha256 !== 'string' || !/^[0-9a-f]{64}$/u.test(detail.contentSha256)) {
-            throw new Error('Runner version detail is invalid');
-        }
-        contentSha256 = detail.contentSha256;
-    }
-    const response = await authedFetch(`/api/cli/runner-versions/${encodeURIComponent(runnerVersionId)}/download`);
-    if (!response.ok)
-        throw new Error(`Failed to download runner version: ${await response.text()}`);
-    const tempDir = mkdtempSync(join(tmpdir(), 'orizu-runner-version-'));
-    const cleanup = () => rmSync(tempDir, { recursive: true, force: true });
+    // ORI-2429: the download runs on Effect (runner-folders.ts); this adapter
+    // keeps the { runnerDir, cleanup } shape for the existing Promise callers.
+    const { downloadedRunner, openScope, RemovalLedger } = await import('./runner-folders.js');
+    const { Effect, Scope } = await import('effect');
+    const ledger = new RemovalLedger();
+    const { scope, close } = openScope();
     try {
-        const zipBytes = new Uint8Array(await response.arrayBuffer());
-        if (zipBytes.byteLength > ARTIFACT_MAX_BYTES)
-            throw new Error(`Runner artifact exceeds ${ARTIFACT_MAX_BYTES} bytes`);
-        if (contentSha256 && createHash('sha256').update(zipBytes).digest('hex') !== contentSha256)
-            throw new Error('Runner artifact digest mismatch');
-        const zipPath = join(tempDir, 'runner.zip'), runnerDir = join(tempDir, 'runner');
-        writeFileSync(zipPath, zipBytes);
-        unzip(zipPath, runnerDir);
-        return { runnerDir, cleanup };
+        const { runnerDir } = await Effect.runPromise(downloadedRunner(runnerVersionId, ledger, verifyRegisteredDigest).pipe(Effect.provideService(Scope.Scope, scope)));
+        return {
+            runnerDir,
+            cleanup: () => {
+                close();
+                const [failure] = ledger.errors();
+                if (failure !== undefined)
+                    throw failure;
+            },
+        };
     }
     catch (error) {
-        throwWithCleanup(error, [cleanup], `Runner ${runnerVersionId} materialization failed and cleanup also failed`);
+        // downloadedRunner already removed this runner's folder on its own failure.
+        close();
+        throw error;
     }
 }
-export function cleanupMaterializedRunners(cleanups) {
-    cleanupAll(cleanups, 'Failed to clean materialized runner directories');
-}

package/dist/session-publish.d.ts

@@ -0,0 +1,8 @@
+export interface SessionPublishIo {
+    json: boolean;
+    print: (line: string) => void;
+}
+export declare function runSessionPublish(io: SessionPublishIo, options?: {
+    message?: string | null;
+}): Promise<number>;
+//# sourceMappingURL=session-publish.d.ts.map

package/dist/session-publish.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-publish.d.ts","sourceRoot":"","sources":["../src/session-publish.ts"],"names":[],"mappings":"AAkBA,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,OAAO,CAAA;IACb,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;CAC9B;AA6BD,wBAAsB,iBAAiB,CAAC,EAAE,EAAE,gBAAgB,EAAE,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CA4ExH"}