fix(effect): scopedTempDirectory keeps the force:true finalizer of the former try/finally rm

rc.112's makeTempDirectoryScoped finalizes with rm({ recursive: true })
and orDie, so an operation that removed its own staging directory would
reject an already-successful listMcp/invokeMcp/... call or the Codex
validator's AB6033 result with ENOENT at scope close. Both sites now use
scopedTempDirectory (makeTempDirectory + rm({ recursive, force })), with
a regression test.

Author: ScriptedAlchemy

docs/effect-conventions.md

@@ -237,8 +237,14 @@ contract).
   modules. `fromFileUrl` fails with `BadArgument`; `Effect.orDie` it when the
   URL is built from `import.meta.url`.
 - Temporary directories whose lifetime ends with the enclosing operation:
-  `makeTempDirectoryScoped` inside `Effect.scoped`, replacing `mkdtemp` +
-  `try`/`finally` `rm`. **Not** when ownership of the directory is
+  a scoped temp directory inside `Effect.scoped`, replacing `mkdtemp` +
+  `try`/`finally` `rm`. In `agent-bundle` use `scopedTempDirectory` from
+  `src/effect/platform.ts`, not `fs.makeTempDirectoryScoped` directly: the
+  rc.112 finalizer removes without `force`, so an operation that deletes its
+  own staging directory would die with ENOENT at scope close, where the old
+  `rm(dir, { recursive: true, force: true })` succeeded. Tests may use
+  `makeTempDirectoryScoped` (nothing removes the fixture underneath them).
+  **Not** when ownership of the directory is
   transferred to a longer-lived object (the MCP session plugin-data dir in
   `dev/mcp-session/mcp-session-service.ts`): a scoped temp is removed when
   the scope closes, which is too early there.
@@ -301,16 +307,16 @@ provides `NodeServices.layer` once. Measured on rc.112 (bundled by Rslib,
 the bundle.
 
 `packages/agent-bundle/src/effect/platform.ts` owns the framework's platform
-layer: `platformLayer` (= `NodeServices.layer`), `unwrapPlatformError`, and
-`runWithPlatform`, which provides the layer and unwraps `PlatformError`
+layer: `platformLayer` (= `NodeServices.layer`), `scopedTempDirectory`,
+`unwrapPlatformError`, and `runWithPlatform`, which provides the layer and unwraps `PlatformError`
 before handing off to `boundary.ts`'s `runPromise`. It is the only module
 that imports `effect/PlatformError`: `boundary.ts` is bundled into every
 emitted hook wrapper, and the error class would drag `Data.TaggedError` into
 each one (measured: +12 kB per hook). Phase-1 callers are the throwaway
 artifact in `api.ts` (`listMcp` / `invokeMcp` / `runMcp` / `listHooks` /
 `simulateHook` without `artifact`) and the Codex validator's
-schema-generation directory, both `makeTempDirectoryScoped` inside
-`Effect.scoped`. Emitted artifacts, hook wrappers, and compiler hot paths
+schema-generation directory, both `scopedTempDirectory` (the `force: true`
+finalizer) inside `Effect.scoped`. Emitted artifacts, hook wrappers, and compiler hot paths
 never import this module; the dev server picks it up in phase 2 through
 `makeScopedEffectRuntime(platformLayer)`.
 

packages/agent-bundle/src/api.ts

@@ -2,7 +2,7 @@ import { execFile as executeFile } from 'node:child_process';
 import { join, resolve } from 'node:path';
 import { promisify } from 'node:util';
 
-import { Effect, FileSystem } from 'effect';
+import { Effect } from 'effect';
 
 import { capabilityIsSupported, unavailableCapability } from './adapters/capability-state.ts';
 import { createDefaultRegistry, TargetRegistry } from './adapters/registry.ts';
@@ -166,7 +166,7 @@ import {
 // Imported after the service modules on purpose: the position of
 // `effect/lift.ts` in the module graph fixes its position in the emitted
 // hook bundles, and this order keeps those bundles byte-identical.
-import { runWithPlatform } from './effect/platform.ts';
+import { runWithPlatform, scopedTempDirectory } from './effect/platform.ts';
 import { liftPromise } from './effect/lift.ts';
 
 export {
@@ -579,8 +579,7 @@ const temporaryArtifact = async <Result>(
   // to the project (same filesystem as a real `artifact/`), removed when the
   // build or the operation settles, success or failure.
   return runWithPlatform(Effect.scoped(Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem;
-    const artifact = yield* fs.makeTempDirectoryScoped({
+    const artifact = yield* scopedTempDirectory({
       directory: resolve(options.root),
       prefix: '.agent-bundle-artifact-',
     });

packages/agent-bundle/src/effect/platform.ts

@@ -1,5 +1,5 @@
 import * as NodeServices from '@effect/platform-node/NodeServices';
-import { Effect, type Layer } from 'effect';
+import { Effect, FileSystem, type Layer, type Scope } from 'effect';
 import { PlatformError } from 'effect/PlatformError';
 
 import { runPromise, type RunPromiseOptions } from './boundary.ts';
@@ -36,6 +36,27 @@ export const unwrapPlatformError = <E>(error: E): Exclude<E, PlatformError> | Er
     ? (error.cause instanceof Error ? error.cause : error)
     : (error as Exclude<E, PlatformError>);
 
+/**
+ * A temporary directory that lives exactly as long as the enclosing scope,
+ * with the `rm(dir, { recursive: true, force: true })` finalizer the
+ * `try`/`finally` sites had before they moved onto Effect. rc.112's own
+ * `makeTempDirectoryScoped` finalizes without `force`, so an operation that
+ * removes (or renames away) its own staging directory would die with ENOENT
+ * at scope close and reject a call that had already succeeded. A finalizer
+ * failure other than "already gone" is still a defect, as the `finally`
+ * throw was.
+ */
+export const scopedTempDirectory = (
+  options?: { readonly directory?: string; readonly prefix?: string },
+): Effect.Effect<string, PlatformError, FileSystem.FileSystem | Scope.Scope> =>
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    return yield* Effect.acquireRelease(
+      fs.makeTempDirectory(options),
+      (directory) => Effect.orDie(fs.remove(directory, { force: true, recursive: true })),
+    );
+  });
+
 /**
  * Run a platform-dependent Effect program at a Promise edge. Same failure
  * contract as `runPromise`, with `PlatformError` unwrapped to its Node cause.

packages/agent-bundle/src/host-contracts/codex-plugin-validation.ts

@@ -26,7 +26,7 @@ import {
 // Imported last on purpose: see the matching note in `src/api.ts` — the
 // position of `effect/lift.ts` in the module graph keeps the emitted hook
 // bundles byte-identical.
-import { runWithPlatform } from '../effect/platform.ts';
+import { runWithPlatform, scopedTempDirectory } from '../effect/platform.ts';
 import { liftPromise } from '../effect/lift.ts';
 
 const maximumOutputBytes = 1024 * 1024;
@@ -276,8 +276,7 @@ const schemaGenerationDiagnostics = (
     readonly version: string | undefined;
   }>,
 ): Effect.Effect<readonly Diagnostic[], PlatformError, FileSystem.FileSystem> => Effect.scoped(Effect.gen(function* () {
-  const fs = yield* FileSystem.FileSystem;
-  const outputDirectory = yield* fs.makeTempDirectoryScoped({ prefix: 'agent-bundle-codex-schema-' });
+  const outputDirectory = yield* scopedTempDirectory({ prefix: 'agent-bundle-codex-schema-' });
   const started = yield* liftPromise(() => options.run(Object.freeze({
     args: Object.freeze(['app-server', 'generate-json-schema', '--out', outputDirectory]),
     cwd: options.cwd,

packages/agent-bundle/tests/effect-platform.test.ts

@@ -7,7 +7,7 @@ import { describe, expect, it } from '@rstest/core';
 
 import { DiagnosticError } from '../src/core/diagnostics.ts';
 import { liftPromise } from '../src/effect/lift.ts';
-import { platformLayer, runWithPlatform, unwrapPlatformError } from '../src/effect/platform.ts';
+import { platformLayer, runWithPlatform, scopedTempDirectory, unwrapPlatformError } from '../src/effect/platform.ts';
 import * as devApi from '../src/dev/index.ts';
 import * as rootApi from '../src/index.ts';
 
@@ -64,7 +64,7 @@ describe('effect platform layer (agent-bundle)', () => {
     try {
       const directory = await runWithPlatform(Effect.scoped(Effect.gen(function* () {
         const fs = yield* FileSystem.FileSystem;
-        const created = yield* fs.makeTempDirectoryScoped({ directory: parent, prefix: '.staging-' });
+        const created = yield* scopedTempDirectory({ directory: parent, prefix: '.staging-' });
         expect(created.startsWith(join(parent, '.staging-'))).toBe(true);
         yield* fs.writeFileString(join(created, 'manifest.json'), '{}');
         yield* Effect.promise(() => access(created));
@@ -82,8 +82,7 @@ describe('effect platform layer (agent-bundle)', () => {
     const failure = new DiagnosticError([{ code: 'AB7200', message: 'rebuild failed', severity: 'error' }]);
     try {
       await expect(runWithPlatform(Effect.scoped(Effect.gen(function* () {
-        const fs = yield* FileSystem.FileSystem;
-        directory = yield* fs.makeTempDirectoryScoped({ directory: parent, prefix: '.staging-' });
+        directory = yield* scopedTempDirectory({ directory: parent, prefix: '.staging-' });
         yield* liftPromise(() => Promise.reject(failure));
       })))).rejects.toBe(failure);
       expect(directory).toBeDefined();
@@ -93,11 +92,25 @@ describe('effect platform layer (agent-bundle)', () => {
     }
   });
 
+  it('keeps the result when the operation already removed its scoped temp directory', async () => {
+    const parent = await mkdtemp(join(tmpdir(), 'agent-bundle-platform-'));
+    try {
+      const result = await runWithPlatform(Effect.scoped(Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const created = yield* scopedTempDirectory({ directory: parent, prefix: '.staging-' });
+        yield* fs.remove(created, { recursive: true });
+        return 'settled';
+      })));
+      expect(result).toBe('settled');
+    } finally {
+      await rm(parent, { force: true, recursive: true });
+    }
+  });
+
   it('throws the Node error when the temp directory cannot be created', async () => {
     const missingParent = join(tmpdir(), 'agent-bundle-platform-missing', String(process.pid));
     await expect(runWithPlatform(Effect.scoped(Effect.gen(function* () {
-      const fs = yield* FileSystem.FileSystem;
-      return yield* fs.makeTempDirectoryScoped({ directory: missingParent, prefix: '.staging-' });
+      return yield* scopedTempDirectory({ directory: missingParent, prefix: '.staging-' });
     })))).rejects.toMatchObject({ code: 'ENOENT', syscall: 'mkdtemp' });
   });
 });