@finalai/final-agent-provider 0.10.1 → 0.11.0

package/dist/modules/sandboxes/computer.mjs

@@ -1,29 +1,21 @@
-import { ProcessInspectionOperation } from "@finalai/agent-protocol/process-inspection";
-import {
-  formatProviderRef,
-  NetworkPolicy,
-  packageRef,
-  SandboxAccess
-} from "@finalai/agent-provider";
+import { Capability, FilesAccess, ScreenAccess, ShellAccess } from "@finalai/agent-protocol";
+import { NetworkPolicy } from "@finalai/agent-provider";
 import {
   defineSandboxProvider,
-  withSandboxNetworking,
-  mapSandboxHandle,
-  SandboxExecutionOperation,
+  FULL_SANDBOX_GRANT,
   materializeSandboxSeeds,
-  PLATFORM_ENVIRONMENT_NAMES,
   platformProcessEnvironment,
   PortProtocol,
   reportPlatformNetworkPolicy,
   SandboxCapability,
+  SandboxExecutionOperation,
   sandboxSeedArtifact,
   sandboxSeedArtifactSchema,
   sandboxSeedFiles,
-  sandboxSeedFilesForStart,
+  sandboxSeedFilesForAttach,
   sandboxSeedIdentity,
-  sandboxWorkspaceId,
-  SandboxWorkspace,
   withPlatformEgressHosts,
+  withSandboxNetworking,
   writePlatformFiles
 } from "@finalai/agent-provider/sandbox";
 import {
@@ -41,7 +33,7 @@ import {
   homeBaselineScript,
   homeContentScript
 } from "./build-scripts.mjs";
-import { sleep as defaultSleep, sha256Hex } from "./bytes.mjs";
+import { canonicalJson, sleep as defaultSleep, sha256Hex } from "./bytes.mjs";
 import { computerEditor } from "./computer-editor.mjs";
 import { readComputerSnapshot } from "./computer-snapshots.mjs";
 import {
@@ -52,30 +44,15 @@ import {
 import { createComputerUseEndpoint } from "./computers-api-mcp.mjs";
 import { createComputersApiTransport } from "./computers-api-transport.mjs";
 import {
-  COMPUTER_SANDBOX_SPECIFIER,
+  COMPUTER_PROVIDER,
   computerEnvironmentSchema,
-  computerOpenOptionsSchema,
-  ComputerWorkspacePolicy
+  DEFAULT_COMPUTER_IMAGE
 } from "./environment.mjs";
-import {
-  computeComputerArtifactKey,
-  computerNeedsBuild,
-  DEFAULT_COMPUTER_IMAGE,
-  resolveComputerSpec
-} from "./guide.mjs";
-import { createTransportSession, sessionForAccess } from "./session.mjs";
-import {
-  guideCommands,
-  installGuideCommands,
-  mountRepositories,
-  repositoryPath,
-  runWorkspaceSetup,
-  startServices,
-  WORKSPACE_ROOT
-} from "./workspace-setup.mjs";
-const computerWorkspaceName = async (options) => options.conversationWorkspace && options.conversationId != null ? `ac-${(await sha256Hex(`${options.conversationId}:${options.target}`)).slice(0, 24)}` : `ab-${compactId(options.bindingId)}`;
-import { COMPUTER_SANDBOX_SPECIFIER as COMPUTER_SANDBOX_SPECIFIER2 } from "./environment.mjs";
-import { computeComputerArtifactKey as computeComputerArtifactKey2 } from "./guide.mjs";
+import { createTransportSession, readOnlySession } from "./session.mjs";
+import { COMPUTER_PROVIDER as COMPUTER_PROVIDER2 } from "./environment.mjs";
+const WORKSPACE_ROOT = "/workspaces";
+const DEFAULT_IDLE_TIMEOUT_SECONDS = 15 * 60;
+const IDLE_TIMEOUT_MARGIN_SECONDS = 5 * 60;
 const computerArtifactSchema = sandboxSeedArtifactSchema.extend({
   version: z.literal(1),
   key: z.string(),
@@ -90,37 +67,26 @@ const computerArtifactSchema = sandboxSeedArtifactSchema.extend({
     z.object({ kind: z.literal("captured"), baseId: z.string() })
   ])
 });
+const networkPolicySchema = z.object({
+  mode: z.nativeEnum(NetworkPolicy),
+  allow: z.array(z.string()).optional()
+});
 const computerStateSchema = z.object({
-  version: z.literal(1),
-  computerId: z.string(),
+  version: z.literal(2),
   computerName: z.string(),
-  workspace: z.nativeEnum(ComputerWorkspacePolicy),
-  access: z.nativeEnum(SandboxAccess),
-  guideVersionId: z.string().nullable(),
-  setupHash: z.string().nullable(),
-  setupPending: z.boolean().default(false),
-  workspaceId: z.string().optional(),
-  networkPolicySaved: z.boolean().optional()
+  // Null until the first attach creates the computer.
+  computerId: z.string().nullable(),
+  // The sandbox setup's network policy, enforced from the computer's first boot.
+  network: networkPolicySchema,
+  // Ports the setup's services listen on.
+  ports: z.array(z.number().int()).default([]),
+  // Workspace Device egress manages this computer's network.
+  networkPolicySaved: z.boolean().default(false)
 });
 const computerSandboxError = (code, message) => Object.assign(new Error(message), { name: "ComputerSandboxError", code });
-const RESERVED_ENV = /* @__PURE__ */ new Set([
-  ...PLATFORM_ENVIRONMENT_NAMES,
-  "DISPLAY",
-  "XDG_RUNTIME_DIR",
-  "PATH",
-  "HOME",
-  "USER",
-  "SHELL",
-  "HOSTNAME"
-]);
-const isReservedEnvName = (name) => name.startsWith("FINAL_NODE_") || RESERVED_ENV.has(name);
 const HTTP_TOKEN_LIFETIME_MS = 60 * 6e4;
 const HTTP_TOKEN_RENEW_MS = 5 * 6e4;
 const BUILD_ROOT = "/tmp/final-build";
-const seedsFor = (ctx) => sandboxSeedFiles({
-  files: ctx.resources.guide == null ? ctx.files : {},
-  resources: ctx.resources
-});
 const CAPTURE_SCRUBBED_PATHS = [
   "/home/user/.bash_history",
   "/home/user/.zsh_history",
@@ -139,6 +105,8 @@ const CAPTURE_SCRUBBED_PATHS = [
   "/home/user/.ssh"
 ];
 const BUILDER_IDLE_TIMEOUT_SECONDS = 2 * 60 * 60;
+const ARTIFACT_KEY_VERSION = 1;
+const PROJECT_ARTIFACT_CAPTURE_PROTOCOL_VERSION = 2;
 const networkPolicyFor = (network) => ({
   mode: network?.egress === ComputerEgressPolicy.Internet ? NetworkPolicy.AllowAll : network?.egress === ComputerEgressPolicy.Allowlist ? NetworkPolicy.Allowlist : NetworkPolicy.DenyAll,
   allow: network?.allow ?? []
@@ -149,34 +117,66 @@ const computerEgressOf = (policy) => {
   return { egress: ComputerEgressPolicy.Allowlist, allow: policy.allow ?? [] };
 };
 const egressFor = (ctx, requested) => computerEgressOf(withPlatformEgressHosts(ctx, requested));
-const LINEAGE_PREFIX = "lineage:";
-const portOf = (url) => {
-  try {
-    const parsed = new URL(url);
-    if (parsed.port !== "") return Number(parsed.port);
-    return parsed.protocol === "https:" ? 443 : 80;
-  } catch {
-    return null;
-  }
+const computerNetworkPolicyOf = (setup) => {
+  const network = setup?.network;
+  if (network == null) return { mode: NetworkPolicy.AllowAll };
+  if ((network.deny ?? []).length > 0)
+    throw computerSandboxError(
+      "invalid_environment",
+      "A Final computer cannot deny individual hosts; list the hosts to allow instead"
+    );
+  if (network.allow == null) return { mode: NetworkPolicy.AllowAll };
+  return network.allow.length === 0 ? { mode: NetworkPolicy.DenyAll } : { mode: NetworkPolicy.Allowlist, allow: [...network.allow] };
 };
+const LINEAGE_PREFIX = "lineage:";
 const compactId = (id) => id.replaceAll("-", "");
-const sandboxWorkspaceOf = {
-  [ComputerWorkspacePolicy.Session]: SandboxWorkspace.Session,
-  [ComputerWorkspacePolicy.Conversation]: SandboxWorkspace.Conversation,
-  [ComputerWorkspacePolicy.Ephemeral]: SandboxWorkspace.Ephemeral
-};
+const computerNameFor = async (sandboxId) => `as-${(await sha256Hex(sandboxId)).slice(0, 24)}`;
 const isRunningState = (state) => state === ComputerState.Running || state === ComputerState.Paused || state === ComputerState.Resuming;
 const hasNothingToPause = (state) => state === ComputerState.Stopped || state === ComputerState.Shelved || state === ComputerState.Error || state === ComputerState.Deleted;
 const pauseMayHaveSettled = (error) => isComputersApiError(error) && error.statusCode != null && (error.statusCode === 404 || error.statusCode === 409 || error.statusCode >= 500);
 const RUNNING_POLL_MAX_MS = 5e3;
+const computerNeedsBuild = (build) => build != null && (build.steps.length > 0 || build.verify.length > 0);
+const computeComputerArtifactKey = async (inputs) => {
+  if (!computerNeedsBuild(inputs.build)) {
+    const hex2 = await sha256Hex(canonicalJson({ v: ARTIFACT_KEY_VERSION, image: inputs.image }));
+    return `img-${hex2.slice(0, 16)}`;
+  }
+  const hex = await sha256Hex(
+    canonicalJson({
+      v: ARTIFACT_KEY_VERSION,
+      image: inputs.image,
+      build: { steps: inputs.build?.steps ?? [], verify: inputs.build?.verify ?? [] },
+      diskGb: inputs.diskGb
+    })
+  );
+  return `pa-g${hex.slice(0, 16)}-c${PROJECT_ARTIFACT_CAPTURE_PROTOCOL_VERSION}`;
+};
+const offerContextOf = (ctx) => ({
+  organizationId: ctx.organizationId,
+  projectId: ctx.projectId,
+  sandboxId: ctx.sandboxId,
+  credentials: ctx.credentials,
+  actingUser: ctx.actingUser,
+  identity: ctx.identity,
+  platformEgressHosts: ctx.platformEgressHosts,
+  platformNetworkPolicy: ctx.platformNetworkPolicy
+});
 const createComputerSandboxProvider = (config) => {
   const log = config.log ?? (() => void 0);
   const randomUuid = config.randomUuid ?? (() => crypto.randomUUID());
   const now = config.now ?? (() => Date.now());
   const sleep = config.sleep ?? defaultSleep;
-  const defaultImage = config.defaultImage ?? DEFAULT_COMPUTER_IMAGE;
   const runningWaitMs = config.runningWaitMs ?? 5 * 6e4;
-  const clientFor = (credentials) => createComputersApiClient({ config: config.computersApi ?? {}, credentials });
+  const credentialsFor = (ctx) => ({
+    computersAccess: async (args) => ({
+      baseUrl: config.computersApiUrl,
+      token: (await ctx.identity({ audience: config.computersApiUrl, refresh: args?.refresh === true })).token
+    })
+  });
+  const clientFor = (ctx) => createComputersApiClient({
+    config: config.computersApi ?? {},
+    credentials: credentialsFor(ctx)
+  });
   const registerImage = (client, reference) => client.registerImage(
     config.registryCredentialId == null ? { reference } : { reference, registryCredentialId: config.registryCredentialId }
   );
@@ -217,23 +217,6 @@ const createComputerSandboxProvider = (config) => {
     }
     return version.id;
   };
-  const loadVariables = async (ctx, spec) => {
-    const env = {};
-    for (const [name, value] of Object.entries(spec.parameters.env)) {
-      if (isReservedEnvName(name))
-        throw computerSandboxError("invalid_environment", `${name} is reserved`);
-      env[name] = value;
-    }
-    for (const name of spec.parameters.variables) {
-      if (isReservedEnvName(name))
-        throw computerSandboxError("invalid_environment", `${name} is reserved`);
-      const value = await ctx.variables.get(name);
-      if (value == null)
-        throw computerSandboxError("invalid_environment", `variable ${name} is not set`);
-      env[name] = value;
-    }
-    return env;
-  };
   const mcpClosers = /* @__PURE__ */ new Map();
   const closeComputerMcp = async (computerId) => {
     const results = await Promise.allSettled(
@@ -254,44 +237,186 @@ const createComputerSandboxProvider = (config) => {
       );
     }
   };
+  const createNetworkingController = (options) => {
+    try {
+      if (config.networking == null) throw new Error("Workspace networking extension is required");
+      return config.networking.controller(options);
+    } catch (cause) {
+      options.onClose?.();
+      throw cause;
+    }
+  };
+  const managedWorkspaces = /* @__PURE__ */ new Set();
+  const savedPolicyWorkspaces = /* @__PURE__ */ new Set();
+  const workspaceKey = (ctx) => `${ctx.organizationId}:${ctx.sandboxId}`;
+  const needsWorkspaceNetworking = async (ctx, query = {}) => {
+    const needed = await config.networking?.enabled({
+      ctx,
+      workspaceId: ctx.sandboxId,
+      grant: FULL_SANDBOX_GRANT,
+      ...query
+    }) ?? false;
+    if (needed) managedWorkspaces.add(workspaceKey(ctx));
+    return needed || managedWorkspaces.has(workspaceKey(ctx));
+  };
+  const preservePolicy = async (args) => {
+    if (config.networking == null) throw new Error("Workspace networking extension is required");
+    const retained = await config.networking.prepare({
+      ctx: args.ctx,
+      workspaceId: args.ctx.sandboxId,
+      policy: args.policy
+    });
+    await args.ctx.platformNetworkPolicy?.(retained ?? args.policy);
+    savedPolicyWorkspaces.add(workspaceKey(args.ctx));
+  };
+  const teardownComputer = async (args) => {
+    const failures = [];
+    let managed = args.policySaved || managedWorkspaces.has(workspaceKey(args.ctx));
+    let queryFailed = false;
+    try {
+      managed = await needsWorkspaceNetworking(args.ctx, { teardown: true }) || args.policySaved;
+    } catch (cause) {
+      failures.push(cause);
+      queryFailed = true;
+    }
+    const results = await Promise.allSettled([
+      (async () => {
+        if (managed && args.fence) {
+          const client = clientFor(args.ctx);
+          let mayFence = args.policySaved || savedPolicyWorkspaces.has(workspaceKey(args.ctx));
+          try {
+            if (config.networking != null) {
+              await preservePolicy({
+                ctx: args.ctx,
+                policy: networkPolicyFor(await client.getNetworkPolicy(args.computerId))
+              });
+              mayFence = true;
+            }
+          } catch (cause) {
+            if (isComputersApiStatus(cause, 404)) mayFence = false;
+            else failures.push(cause);
+          }
+          if (mayFence) {
+            try {
+              await client.setNetworkPolicy(
+                args.computerId,
+                { egress: ComputerEgressPolicy.None },
+                { autoResume: false }
+              );
+            } catch (cause) {
+              let settled = isComputersApiStatus(cause, 404);
+              if (!settled && isComputersApiStatus(cause, 409)) {
+                try {
+                  const latest = await client.getComputer(args.computerId);
+                  settled = latest == null || latest.state === ComputerState.Deleted;
+                } catch (lookup) {
+                  failures.push(lookup);
+                }
+              }
+              if (!settled) failures.push(cause);
+            }
+          }
+        }
+        await args.finish();
+      })(),
+      (async () => {
+        if (managed && config.networking == null)
+          throw new Error(
+            "Managed Computer teardown requires the workspace egress integration to revoke Device access"
+          );
+        if (config.networking != null && (managed || queryFailed))
+          await config.networking.suspend({ ctx: args.ctx, workspaceId: args.ctx.sandboxId });
+      })()
+    ]);
+    for (const result of results) if (result.status === "rejected") failures.push(result.reason);
+    if (failures.length === 1) throw failures[0];
+    if (failures.length > 1)
+      throw new AggregateError(failures, "Computer teardown and egress revocation failed");
+  };
+  const setupSession = (args) => {
+    const transport = createComputersApiTransport({
+      client: args.client,
+      computerId: args.info.id
+    });
+    const sandbox = createTransportSession({
+      id: args.info.id,
+      description: `setup of ${args.info.name}`,
+      workspaceRoot: WORKSPACE_ROOT,
+      transport,
+      baseEnv: args.env,
+      randomUuid,
+      network: {
+        ports: [],
+        getPortEndpoint: async () => {
+          throw new Error("setup sessions expose no ports");
+        },
+        stop: async () => void 0,
+        destroy: async () => void 0
+      }
+    });
+    return { sandbox, transport };
+  };
+  const workspaceNetworking = (args) => {
+    if (config.networking == null || !args.enabled) return void 0;
+    return createNetworkingController({
+      ctx: args.ctx,
+      sandbox: args.sandbox,
+      workspaceId: args.ctx.sandboxId,
+      grant: FULL_SANDBOX_GRANT,
+      onClose: args.onClose,
+      initialNetworkPolicy: args.initialNetworkPolicy,
+      namespaceExists: async () => {
+        const current = await args.client.getComputer(args.info.id);
+        return current?.state === ComputerState.Running;
+      },
+      log,
+      afterBlock: () => args.client.setNetworkPolicy(
+        args.info.id,
+        { egress: ComputerEgressPolicy.None },
+        { autoResume: false }
+      ),
+      afterGuard: (policy) => args.client.setNetworkPolicy(
+        args.info.id,
+        egressFor(args.ctx, policy ?? { mode: NetworkPolicy.DenyAll }),
+        { autoResume: false }
+      )
+    });
+  };
   const buildHandle = async (args) => {
-    const { client, info, spec } = args;
-    const commands = await guideCommands(spec.template);
-    const commandHelp = commands.map(
-      (command) => `Guide command ${command.name}: bash ${command.path}${command.description == null ? "" : ` \u2014 ${command.description}`}`
-    ).join("\n");
+    const { client, info } = args;
     const transport = createComputersApiTransport({ client, computerId: info.id });
-    const ports = [
-      ...new Set(
-        spec.template.services.flatMap((service) => {
-          const port = service.ready == null ? null : portOf(service.ready.url);
-          return port == null ? [] : [port];
-        })
-      )
-    ];
     let httpToken = null;
+    const fenceOnStop = async () => {
+      if (args.networking != null)
+        await client.setNetworkPolicy(
+          info.id,
+          { egress: ComputerEgressPolicy.None },
+          { autoResume: false }
+        );
+      else if (!args.passive)
+        await teardownComputer({
+          ctx: args.ctx,
+          computerId: info.id,
+          policySaved: args.networkingManaged,
+          fence: true,
+          finish: async () => {
+          }
+        });
+    };
     const session = createTransportSession({
       id: info.id,
-      description: `Final computer ${info.name}${spec.guide == null ? "" : ` (${spec.guide.title} v${spec.guide.number})`}${commands.length === 0 ? "" : `
-${commandHelp}`}`,
+      description: `Final computer ${info.name}`,
       workspaceRoot: WORKSPACE_ROOT,
       transport,
       baseEnv: args.env,
       randomUuid,
       network: {
-        ports,
+        ports: [...args.ports],
         // The computer's hostname with a preview token, which opens its HTTP ports only.
         getPortEndpoint: async ({ port, protocol }) => {
-          const managed = args.networkingManaged === true || args.access === SandboxAccess.Read && await needsWorkspaceNetworking(
-            args.ctx,
-            sandboxWorkspaceId({
-              session: args.ctx.session,
-              workspace: sandboxWorkspaceOf[args.spec.parameters.workspace]
-            }),
-            { access: args.access }
-          );
+          const managed = args.networkingManaged || args.passive && await needsWorkspaceNetworking(args.ctx);
           if (managed && args.networking == null)
-            throw new Error("Managed workspace previews require an active write binding");
+            throw new Error("Managed workspace previews require an attached sandbox");
           const deadline = (await args.networking?.authorizeExternalAccess())?.expiresAtMs;
           if (deadline != null && deadline <= now())
             throw new Error("Refresh workspace networking before preview access");
@@ -301,7 +426,7 @@ ${commandHelp}`}`,
             const expiresAtMs = Math.min(now() + HTTP_TOKEN_LIFETIME_MS, deadline ?? Infinity);
             const token = await client.createPreviewToken({
               computerId: info.id,
-              name: `agent sandbox ${args.ctx.session.bindingId}`,
+              name: `agent sandbox ${args.ctx.sandboxId}`,
               expiresAt: new Date(expiresAtMs)
             });
             httpToken = { token, expiresAtMs };
@@ -315,24 +440,7 @@ ${commandHelp}`}`,
         stop: async () => {
           const failures = [];
           try {
-            if (args.networking != null)
-              await client.setNetworkPolicy(
-                info.id,
-                { egress: ComputerEgressPolicy.None },
-                { autoResume: false }
-              );
-            else if (args.access !== SandboxAccess.Read)
-              await teardownComputer({
-                ctx: args.ctx,
-                computerId: info.id,
-                computerName: info.name,
-                workspace: spec.parameters.workspace,
-                policySaved: args.networkingManaged === true,
-                workspaceId: args.ctx.session.workspaceId,
-                fence: true,
-                finish: async () => {
-                }
-              });
+            await fenceOnStop();
           } catch (cause) {
             try {
               if (!await deletedAfterFenceError({ client, computerId: info.id, cause }))
@@ -375,14 +483,11 @@ ${commandHelp}`}`,
             if (failures.length > 1)
               throw new AggregateError(failures, "Computer delete or MCP cleanup failed");
           };
-          if (args.networking == null && args.access !== SandboxAccess.Read)
+          if (args.networking == null && !args.passive)
             await teardownComputer({
               ctx: args.ctx,
               computerId: info.id,
-              computerName: info.name,
-              workspace: spec.parameters.workspace,
-              policySaved: args.networkingManaged === true,
-              workspaceId: args.ctx.session.workspaceId,
+              policySaved: args.networkingManaged,
               fence: true,
               finish
             });
@@ -391,13 +496,13 @@ ${commandHelp}`}`,
       }
     });
     let computerUseInstalled = null;
-    if (args.access !== SandboxAccess.Read) {
+    if (!args.passive) {
       try {
         computerUseInstalled = (await client.computerUseStatus(info.id, AbortSignal.timeout(1e3))).installed;
       } catch {
       }
     }
-    const computerUse = args.access === SandboxAccess.Read || computerUseInstalled === false ? null : createComputerUseEndpoint({ client, computerId: info.id, cwd: WORKSPACE_ROOT });
+    const computerUse = args.passive || computerUseInstalled === false ? null : createComputerUseEndpoint({ client, computerId: info.id, cwd: WORKSPACE_ROOT });
     const closeMcp = async () => {
       try {
         await computerUse?.close();
@@ -424,71 +529,30 @@ ${commandHelp}`}`,
     }
     if (screenAvailable) capabilities.push(SandboxCapability.Screen);
     if (computerUse != null) capabilities.push(SandboxCapability.ComputerUse);
-    if (args.access !== SandboxAccess.Read)
+    if (!args.passive)
       capabilities.push(
         SandboxCapability.Process,
         SandboxCapability.DurableProcesses,
         SandboxCapability.NetworkPolicy
       );
-    if (args.access === SandboxAccess.Write && args.networking != null)
+    if (!args.passive && args.networking != null)
       capabilities.push(...config.networking?.capabilities ?? []);
-    const description = {
-      provider: "computer",
-      computerId: info.id,
-      computerName: info.name,
-      workspaceRoot: WORKSPACE_ROOT,
-      transport: transport.kind,
-      guide: spec.guide == null ? null : { slug: spec.guide.slug, number: spec.guide.number },
-      repositories: spec.parameters.repositories.map((repository) => ({
-        alias: repository.alias,
-        path: repositoryPath(repository.alias),
-        repository: repository.repository
-      })),
-      services: spec.template.services.map((service) => ({
-        name: service.name,
-        readyUrl: service.ready?.url ?? null
-      })),
-      commands,
-      capabilities
-    };
     const full = {
       ...session,
       setNetworkPolicy: async (policy) => {
-        if (args.access === SandboxAccess.Read)
-          throw new Error("this sandbox binding is read-only");
+        if (args.passive) throw new Error("this sandbox handle is read-only");
         await client.setNetworkPolicy(info.id, egressFor(args.ctx, policy));
       },
-      describe: () => description,
       capabilities
     };
     if (computerUse != null) full.computerUse = async () => computerUse.endpoint;
-    if (screenAvailable) {
-      full.screen = (options) => client.openScreen(info.id, options);
-    }
-    const sandbox = full;
+    if (screenAvailable) full.screen = (options) => client.openScreen(info.id, options);
     let handle = {
-      sandbox,
+      sandbox: args.passive ? readOnlySession(full) : full,
       onSandboxStop: async () => {
         const failures = [];
         try {
-          if (args.networking != null)
-            await client.setNetworkPolicy(
-              info.id,
-              { egress: ComputerEgressPolicy.None },
-              { autoResume: false }
-            );
-          else
-            await teardownComputer({
-              ctx: args.ctx,
-              computerId: info.id,
-              computerName: info.name,
-              workspace: spec.parameters.workspace,
-              policySaved: args.networkingManaged === true,
-              workspaceId: args.ctx.session.workspaceId,
-              fence: true,
-              finish: async () => {
-              }
-            });
+          await fenceOnStop();
         } catch (cause) {
           try {
             if (!await deletedAfterFenceError({ client, computerId: info.id, cause }))
@@ -531,10 +595,7 @@ ${commandHelp}`}`,
           await teardownComputer({
             ctx: args.ctx,
             computerId: info.id,
-            computerName: info.name,
-            workspace: spec.parameters.workspace,
-            policySaved: args.networkingManaged === true,
-            workspaceId: args.ctx.session.workspaceId,
+            policySaved: args.networkingManaged,
             fence: true,
             finish
           });
@@ -549,11 +610,12 @@ ${commandHelp}`}`,
         }
       }
     };
+    if (args.passive) return handle;
     if (args.networking != null)
       handle = await withSandboxNetworking({
         handle,
         controller: args.networking,
-        access: args.access,
+        grant: FULL_SANDBOX_GRANT,
         initialized: true,
         fetch: config.networking?.fetch,
         executionPolicy: args.ctx.executionPolicy,
@@ -562,220 +624,17 @@ ${commandHelp}`}`,
     else if (config.networking != null)
       handle = await withSandboxNetworking({
         handle,
-        access: args.access,
-        fetch: config.networking?.fetch,
+        grant: FULL_SANDBOX_GRANT,
+        fetch: config.networking.fetch,
         executionPolicy: args.ctx.executionPolicy,
         admission: async () => {
-          if (await needsWorkspaceNetworking(
-            args.ctx,
-            sandboxWorkspaceId({
-              session: args.ctx.session,
-              workspace: sandboxWorkspaceOf[args.spec.parameters.workspace]
-            }),
-            { access: args.access }
-          ))
+          if (await needsWorkspaceNetworking(args.ctx))
             throw new Error(
               "Workspace networking changed; reconnect this sandbox before running tools"
             );
         }
       });
-    return {
-      handle: mapSandboxHandle({
-        handle,
-        mapSandbox: (sandbox2) => sessionForAccess(sandbox2, args.access)
-      })
-    };
-  };
-  const setupSession = (args) => {
-    const transport = createComputersApiTransport({
-      client: args.client,
-      computerId: args.info.id
-    });
-    const sandbox = createTransportSession({
-      id: args.info.id,
-      description: `setup of ${args.info.name}`,
-      workspaceRoot: WORKSPACE_ROOT,
-      transport,
-      baseEnv: args.env,
-      randomUuid,
-      network: {
-        ports: [],
-        getPortEndpoint: async () => {
-          throw new Error("setup sessions expose no ports");
-        },
-        stop: async () => void 0,
-        destroy: async () => void 0
-      }
-    });
-    return { sandbox, transport };
-  };
-  const createNetworkingController = (options) => {
-    try {
-      if (config.networking == null) throw new Error("Workspace networking extension is required");
-      return config.networking.controller(options);
-    } catch (cause) {
-      options.onClose?.();
-      throw cause;
-    }
-  };
-  const workspaceNetworking = (args) => {
-    if (config.networking == null || !args.enabled) return void 0;
-    return createNetworkingController({
-      ctx: {
-        platformEgressHosts: args.ctx.platformEgressHosts,
-        platformNetworkPolicy: args.ctx.platformNetworkPolicy,
-        organizationId: args.ctx.session.organizationId,
-        credentials: args.ctx.credentials,
-        actingUser: args.ctx.actingUser,
-        bindings: args.ctx.bindings
-      },
-      sandbox: args.sandbox,
-      workspaceId: sandboxWorkspaceId({
-        session: args.ctx.session,
-        workspace: sandboxWorkspaceOf[args.spec.parameters.workspace]
-      }),
-      access: args.access,
-      onClose: args.onClose,
-      initialNetworkPolicy: args.initialNetworkPolicy,
-      namespaceExists: async () => {
-        const current = await args.client.getComputer(args.info.id);
-        return current?.state === ComputerState.Running;
-      },
-      log,
-      afterBlock: () => args.client.setNetworkPolicy(
-        args.info.id,
-        { egress: ComputerEgressPolicy.None },
-        { autoResume: false }
-      ),
-      afterGuard: (policy) => args.client.setNetworkPolicy(
-        args.info.id,
-        egressFor(args.ctx, policy ?? { mode: NetworkPolicy.DenyAll }),
-        { autoResume: false }
-      )
-    });
-  };
-  const managedWorkspaces = /* @__PURE__ */ new Set();
-  const savedPolicyWorkspaces = /* @__PURE__ */ new Set();
-  const preservePolicy = async (args) => {
-    if (config.networking == null) throw new Error("Workspace networking extension is required");
-    const retained = await config.networking.prepare({
-      ctx: {
-        platformEgressHosts: args.ctx.platformEgressHosts,
-        platformNetworkPolicy: args.ctx.platformNetworkPolicy,
-        organizationId: args.ctx.session.organizationId,
-        credentials: args.ctx.credentials,
-        actingUser: args.ctx.actingUser,
-        bindings: args.ctx.bindings
-      },
-      workspaceId: args.workspaceId,
-      policy: args.policy
-    });
-    await reportPlatformNetworkPolicy(args.ctx, retained ?? args.policy);
-    savedPolicyWorkspaces.add(args.ctx.session.organizationId + ":" + args.workspaceId);
-  };
-  const needsWorkspaceNetworking = async (ctx, workspaceId, query = {}) => {
-    const needed = await config.networking?.enabled({
-      ctx: {
-        platformEgressHosts: ctx.platformEgressHosts,
-        organizationId: ctx.session.organizationId,
-        credentials: ctx.credentials,
-        actingUser: ctx.actingUser,
-        bindings: ctx.bindings
-      },
-      workspaceId,
-      access: SandboxAccess.Write,
-      ...query
-    }) ?? false;
-    if (needed) managedWorkspaces.add(ctx.session.organizationId + ":" + workspaceId);
-    return needed || managedWorkspaces.has(ctx.session.organizationId + ":" + workspaceId);
-  };
-  const teardownComputer = async (args) => {
-    let workspaceId;
-    try {
-      workspaceId = args.workspaceId ?? sandboxWorkspaceId({
-        session: args.ctx.session,
-        workspace: sandboxWorkspaceOf[args.workspace]
-      });
-    } catch (cause) {
-      try {
-        await args.finish();
-      } catch (cleanup) {
-        throw new AggregateError([cause, cleanup], "Computer identity and teardown failed");
-      }
-      throw cause;
-    }
-    const failures = [];
-    let managed = args.policySaved || managedWorkspaces.has(args.ctx.session.organizationId + ":" + workspaceId);
-    let queryFailed = false;
-    try {
-      managed = await needsWorkspaceNetworking(args.ctx, workspaceId, { teardown: true }) || args.policySaved;
-    } catch (cause) {
-      failures.push(cause);
-      queryFailed = true;
-    }
-    const results = await Promise.allSettled([
-      (async () => {
-        if (managed && args.fence) {
-          const client = clientFor(args.ctx.credentials);
-          let mayFence = args.policySaved || savedPolicyWorkspaces.has(args.ctx.session.organizationId + ":" + workspaceId);
-          try {
-            if (config.networking != null) {
-              await preservePolicy({
-                ctx: args.ctx,
-                workspaceId,
-                policy: networkPolicyFor(await client.getNetworkPolicy(args.computerId))
-              });
-              mayFence = true;
-            }
-          } catch (cause) {
-            if (isComputersApiStatus(cause, 404)) mayFence = false;
-            else failures.push(cause);
-          }
-          if (mayFence) {
-            try {
-              await client.setNetworkPolicy(
-                args.computerId,
-                { egress: ComputerEgressPolicy.None },
-                { autoResume: false }
-              );
-            } catch (cause) {
-              let settled = isComputersApiStatus(cause, 404);
-              if (!settled && isComputersApiStatus(cause, 409)) {
-                try {
-                  const latest = await client.getComputer(args.computerId);
-                  settled = latest == null || latest.state === ComputerState.Deleted;
-                } catch (lookup) {
-                  failures.push(lookup);
-                }
-              }
-              if (!settled) failures.push(cause);
-            }
-          }
-        }
-        await args.finish();
-      })(),
-      (async () => {
-        if (managed && config.networking == null)
-          throw new Error(
-            "Managed Computer teardown requires the workspace egress integration to revoke Device access"
-          );
-        if (config.networking != null && (managed || queryFailed))
-          await config.networking.suspend({
-            ctx: {
-              organizationId: args.ctx.session.organizationId,
-              credentials: args.ctx.credentials,
-              actingUser: args.ctx.actingUser,
-              bindings: args.ctx.bindings
-            },
-            workspaceId
-          });
-      })()
-    ]);
-    for (const result of results) if (result.status === "rejected") failures.push(result.reason);
-    if (failures.length === 1) throw failures[0];
-    if (failures.length > 1)
-      throw new AggregateError(failures, "Computer teardown and egress revocation failed");
-    return workspaceId;
+    return handle;
   };
   const awaitBase = async (client, baseId, key) => {
     const deadline = now() + (config.buildWaitMs ?? 30 * 6e4);
@@ -821,29 +680,18 @@ ${commandHelp}`}`,
       pollMs = Math.min(pollMs * 2, RUNNING_POLL_MAX_MS);
     }
   };
-  const awaitShelved = async (client, computerId) => {
-    const deadline = now() + (config.shelveWaitMs ?? 5 * 6e4);
-    for (; ; ) {
-      const computer = await client.getComputer(computerId);
-      if (computer == null || computer.state === ComputerState.Shelved || computer.state === ComputerState.Deleted)
-        return;
-      if (computer.state === ComputerState.Error)
-        throw computerSandboxError("computer_gone", `computer ${computerId} failed to shelve`);
-      if (now() >= deadline) throw new Error(`computer ${computerId} is still shelving`);
-      await sleep(config.shelvePollMs ?? 2e3);
-    }
-  };
-  const build = async (ctx, spec, key) => {
-    const client = clientFor(ctx.credentials);
-    const diskGb = config.machine?.diskGb ?? null;
+  const build = async (args) => {
+    const { ctx, key } = args;
+    const client = clientFor(ctx);
+    const diskGb = args.machine?.diskGb ?? null;
     const imageVersionId = await readyImageVersion(client, {
-      image: spec.image,
+      image: args.image,
       imageVersionId: null
     });
     const body = {
       name: `ag-${key.slice(4, 20)}-${compactId(randomUuid()).slice(0, 8)}`,
       imageVersionId,
-      ...config.machine,
+      ...args.machine,
       // The base is the root disk; a user volume would keep /home and /workspaces off it.
       userVolumeGb: null,
       // Nothing secret at create: the create env lands in the guest.
@@ -854,7 +702,7 @@ ${commandHelp}`}`,
       idleTimeoutSeconds: BUILDER_IDLE_TIMEOUT_SECONDS,
       tags: ["final-agent-sandbox-build"]
     };
-    if (config.regionSlug != null) body.regionSlug = config.regionSlug;
+    if (args.region != null) body.regionSlug = args.region;
     const builder = await client.createComputer(
       body,
       `agent-guide-build-${(await sha256Hex(`${key}:${randomUuid()}`)).slice(0, 32)}`
@@ -873,8 +721,8 @@ ${homeBaselineScript()}`],
         throw computerSandboxError("build_failed", "failed to record the pre-build home baseline");
       }
       const steps = [
-        ...spec.template.build.steps.map((step) => ({ step, label: "build step" })),
-        ...spec.template.build.verify.map((step) => ({ step, label: "verify step" }))
+        ...args.build.steps.map((step) => ({ step, label: "build step" })),
+        ...args.build.verify.map((step) => ({ step, label: "verify step" }))
       ];
       for (const [index, { step, label }] of steps.entries()) {
         ctx.log?.(`${label} ${index + 1}/${steps.length}`);
@@ -921,7 +769,7 @@ ${step.run}`,
       return {
         version: 1,
         key,
-        image: spec.image,
+        image: args.image,
         diskGb: diskGb ?? base.diskGb,
         seedFiles: {},
         base: { kind: "captured", baseId: base.id }
@@ -946,72 +794,87 @@ ${step.run}`,
       );
     }
     const options = parsed.data;
-    const resolve = (guides) => resolveComputerSpec({ options, guides, defaultImage });
-    const keyFor = async (spec, files) => {
+    const image = options.image ?? config.defaultImage ?? DEFAULT_COMPUTER_IMAGE;
+    const machine = options.machine ?? config.machine;
+    const region = options.region ?? config.regionSlug ?? null;
+    const idleTimeoutFor = (ctx) => options.idleTimeoutSeconds ?? (ctx.lifecycle.parkAfterIdleMs == null ? DEFAULT_IDLE_TIMEOUT_SECONDS : Math.ceil(ctx.lifecycle.parkAfterIdleMs / 1e3) + IDLE_TIMEOUT_MARGIN_SECONDS);
+    const seedsFor = (ctx) => sandboxSeedFiles({ files: ctx.files, resources: ctx.resources });
+    const keyFor = async (files) => {
       const baseKey = await computeComputerArtifactKey({
-        image: spec.image,
-        template: spec.template,
-        diskGb: config.machine?.diskGb ?? null
+        image,
+        build: options.build,
+        diskGb: machine?.diskGb ?? null
       });
       return Object.keys(files).length === 0 ? baseKey : `${baseKey}-s${await sha256Hex(sandboxSeedIdentity(files))}`;
     };
-    const startServicesFor = async (args) => {
-      await startServices({
-        sandbox: args.setup.sandbox,
-        transport: args.setup.transport,
-        template: args.spec.template,
-        // Services run for the computer's life, with the platform's values as they are now.
-        env: await args.env(),
-        randomUuid,
-        log
-      });
+    const retainedBase = async (ctx, baseKey) => {
+      const cached = computerArtifactSchema.safeParse(await ctx.artifacts?.get(baseKey));
+      if (!cached.success || cached.data.key !== baseKey || cached.data.base.kind !== "captured")
+        return null;
+      const client = clientFor(ctx);
+      const base = await client.getBase(cached.data.base.baseId);
+      if (base?.state !== ComputerBaseState.Ready) return null;
+      if (!base.retained && !(await client.setBaseRetention(base.id, true)).retained)
+        throw computerSandboxError(
+          "build_failed",
+          "the Computers API did not retain the prepared base"
+        );
+      return cached.data;
+    };
+    const stateOf = (raw) => {
+      const state = computerStateSchema.safeParse(raw);
+      if (!state.success)
+        throw computerSandboxError(
+          "computer_gone",
+          "this sandbox was recorded by an older computer provider; create it again"
+        );
+      return state.data;
+    };
+    const findComputer = async (client, state) => {
+      const found = await client.getComputer(state.computerId ?? state.computerName);
+      return found == null || found.state === ComputerState.Deleted ? null : found;
     };
-    const awaitRunning = (ctx, rawState, options2) => awaitComputerRunning(
-      clientFor(ctx.credentials),
-      computerStateSchema.pick({ computerId: true }).parse(rawState).computerId,
-      options2.timeoutMs
-    );
     return {
+      capabilities: async () => ({
+        [Capability.Files]: FilesAccess.Write,
+        [Capability.Shell]: ShellAccess.Execute,
+        [Capability.ComputerUse]: ScreenAccess.Control
+      }),
+      // Screen and computer-use availability is known only after attaching the actual Computer.
+      additionalFeatures: async () => config.networking?.capabilities.slice() ?? [],
       processes: async (ctx, rawState, request) => {
-        const state = computerStateSchema.parse(rawState);
-        if (request.operation === ProcessInspectionOperation.Stop && state.access === SandboxAccess.Read)
-          throw new Error("stopping processes requires execute access");
-        const result = await clientFor(ctx.credentials).inspectProcesses(state.computerId, request);
-        return request.operation === ProcessInspectionOperation.Available && "available" in result ? { ...result, canStop: state.access !== SandboxAccess.Read } : result;
+        const state = stateOf(rawState);
+        if (state.computerId == null) throw new Error("this computer has not started yet");
+        return clientFor(ctx).inspectProcesses(state.computerId, request);
       },
       editor: async (ctx, rawState, request) => {
-        const state = computerStateSchema.parse(rawState);
-        if (state.access !== SandboxAccess.Write) {
+        const state = stateOf(rawState);
+        const computerId = state.computerId;
+        if (computerId == null) {
           if (request.operation === "available") return { available: false };
-          throw new Error("editor requires write access");
+          throw new Error("this computer has not started yet");
         }
-        const client = clientFor(ctx.credentials);
+        const client = clientFor(ctx);
         const open = (expiresAtMs) => computerEditor({
           client,
-          computerId: state.computerId,
+          computerId,
           request,
           randomUuid,
           expiresAtMs
         });
         if (request.operation === "available" || request.operation === "close") return open();
-        const workspaceId = ctx.workspaceId ?? state.workspaceId;
-        if (state.networkPolicySaved === true && ctx.workspaceId != null && state.workspaceId != null && ctx.workspaceId !== state.workspaceId)
-          throw new Error("Editor workspace identity does not match its retained provider state");
         if (config.networking == null) {
-          if (state.networkPolicySaved === true)
+          if (state.networkPolicySaved)
             throw new Error("Device networking control is required before opening this editor");
           return open();
         }
-        if (workspaceId == null)
-          throw new Error(
-            "The host must supply logical workspace identity before opening an egress-aware editor"
-          );
-        const managedKey = ctx.organizationId + ":" + workspaceId;
-        const managed = state.networkPolicySaved === true || managedWorkspaces.has(managedKey) || await config.networking.enabled({ ctx, workspaceId, access: SandboxAccess.Write });
+        if (ctx.sandboxId == null)
+          throw new Error("The host must name the sandbox before opening an egress-aware editor");
+        const networkingCtx = { ...ctx, sandboxId: ctx.sandboxId };
+        const managed = state.networkPolicySaved || await needsWorkspaceNetworking(networkingCtx);
         if (!managed) return open();
-        managedWorkspaces.add(managedKey);
-        config.networking.validateWorkspaceId?.(workspaceId);
-        const info = await client.getComputer(state.computerId);
+        config.networking.validateWorkspaceId?.(ctx.sandboxId);
+        const info = await client.getComputer(computerId);
         if (info == null || info.state !== ComputerState.Running)
           throw new Error("Computer must be running before editor access");
         const initialNetworkPolicy = networkPolicyFor(await client.getNetworkPolicy(info.id));
@@ -1019,9 +882,9 @@ ${step.run}`,
         const manager = createNetworkingController({
           sandbox: setup.sandbox,
           onClose: () => setup.transport.close(),
-          workspaceId,
+          workspaceId: ctx.sandboxId,
           ctx,
-          access: SandboxAccess.Write,
+          grant: FULL_SANDBOX_GRANT,
           initialNetworkPolicy,
           afterBlock: () => client.setNetworkPolicy(
             info.id,
@@ -1047,138 +910,116 @@ ${step.run}`,
         return open(deadline ?? void 0);
       },
       readSnapshot: async (ctx, rawState, request) => {
-        const state = computerStateSchema.parse(rawState);
+        const state = stateOf(rawState);
+        if (state.computerId == null) return null;
         return readComputerSnapshot({
-          client: clientFor(ctx.credentials),
+          client: clientFor(ctx),
           computerId: state.computerId,
           request
         });
       },
-      // The merged parameters' workspace: the binding's, else the saved version's default.
-      workspace: async (ctx) => sandboxWorkspaceOf[(await resolve(ctx.guides)).parameters.workspace],
-      // Screen and computer-use availability is known only after attaching the actual Computer.
-      additionalCapabilities: async () => config.networking?.capabilities.slice() ?? [],
-      artifactKey: async (ctx) => keyFor(await resolve(ctx.guides), seedsFor(ctx)),
-      // Registers an image reference so its version builds ahead of the first start;
-      // a lineage needs nothing until then.
+      artifactKey: async (ctx) => keyFor(seedsFor(ctx)),
+      // Builds the base an environment with build steps needs, or registers an
+      // image reference so its version builds ahead of the first attach (a
+      // lineage needs nothing until then).
       prepare: async (ctx) => {
-        const spec = await resolve(ctx.guides);
         const seedFiles = seedsFor(ctx);
-        const key = await keyFor(spec, seedFiles);
+        const key = await keyFor(seedFiles);
         const seedArtifact = await sandboxSeedArtifact(ctx, seedFiles);
-        if (computerNeedsBuild(spec)) {
-          const baseKey = await keyFor(spec, {});
-          const prepared = spec.guide?.preparedArtifact;
-          if (prepared?.key === baseKey && prepared.providerRef === formatProviderRef(packageRef(COMPUTER_SANDBOX_SPECIFIER))) {
-            const cached2 = computerArtifactSchema.safeParse(prepared.artifact);
-            if (cached2.success && cached2.data.key === baseKey && cached2.data.base.kind === "captured") {
-              const base = await clientFor(ctx.credentials).getBase(cached2.data.base.baseId);
-              if (base?.state === ComputerBaseState.Ready) {
-                if (!base.retained) {
-                  const retained = await clientFor(ctx.credentials).setBaseRetention(base.id, true);
-                  if (!retained.retained)
-                    throw computerSandboxError(
-                      "build_failed",
-                      "the Computers API did not retain the prepared base"
-                    );
-                }
-                return { ...cached2.data, key, ...seedArtifact };
-              }
-            }
-          }
-          const cached = computerArtifactSchema.safeParse(await ctx.artifacts?.get(baseKey));
-          if (cached.success && cached.data.key === baseKey && cached.data.base.kind === "captured") {
-            const base = await clientFor(ctx.credentials).getBase(cached.data.base.baseId);
-            if (base?.state === ComputerBaseState.Ready) {
-              if (!base.retained) {
-                const retained = await clientFor(ctx.credentials).setBaseRetention(base.id, true);
-                if (!retained.retained)
-                  throw computerSandboxError(
-                    "build_failed",
-                    "the Computers API did not retain the prepared base"
-                  );
-              }
-              return { ...cached.data, key, ...seedArtifact };
-            }
-          }
-          const built = await build(ctx, spec, baseKey);
+        if (options.build != null && computerNeedsBuild(options.build)) {
+          const baseKey = await keyFor({});
+          const retained = await retainedBase(ctx, baseKey);
+          if (retained != null) return { ...retained, key, ...seedArtifact };
+          const built = await build({
+            ctx,
+            image,
+            build: options.build,
+            machine,
+            region,
+            key: baseKey
+          });
           await ctx.artifacts?.put(baseKey, built);
           return { ...built, key, ...seedArtifact };
         }
-        const imageVersionId = spec.image.startsWith(LINEAGE_PREFIX) ? null : (await registerImage(clientFor(ctx.credentials), spec.image)).id;
-        ctx.log?.(`computer base ${key} is image ${spec.image}`);
+        const imageVersionId = image.startsWith(LINEAGE_PREFIX) ? null : (await registerImage(clientFor(ctx), image)).id;
+        ctx.log?.(`computer base ${key} is image ${image}`);
         return {
           version: 1,
           key,
-          image: spec.image,
-          diskGb: config.machine?.diskGb ?? null,
+          image,
+          diskGb: machine?.diskGb ?? null,
           ...seedArtifact,
-          base: { kind: "image", image: spec.image, imageVersionId }
+          base: { kind: "image", image, imageVersionId }
         };
       },
-      awaitRunning: async (ctx, state, options2) => {
-        await awaitRunning(ctx, state, options2);
+      // Records the computer; the first attach creates it. The setup's network
+      // policy is checked now so a policy a computer cannot enforce never boots.
+      create: async (ctx, { setup }) => {
+        const network = computerNetworkPolicyOf(setup);
+        const ports = [
+          ...new Set(
+            (setup?.services ?? []).flatMap(
+              (service) => service.port == null ? [] : [service.port]
+            )
+          )
+        ];
+        return {
+          state: {
+            version: 2,
+            computerName: await computerNameFor(ctx.sandboxId),
+            computerId: null,
+            network,
+            ports,
+            networkPolicySaved: false
+          },
+          region
+        };
       },
-      start: async (ctx, openOptions, rawArtifact) => {
-        const access = computerOpenOptionsSchema.parse(openOptions ?? {}).access;
-        const spec = await resolve(ctx.guides);
-        const policy = withPlatformEgressHosts(ctx, spec.parameters.networkPolicy);
-        const egress = computerEgressOf(policy);
+      awaitRunning: async (ctx, rawState, options2) => {
+        const state = stateOf(rawState);
+        await awaitComputerRunning(
+          clientFor(ctx),
+          state.computerId ?? state.computerName,
+          options2.timeoutMs
+        );
+      },
+      attach: async (ctx, { artifact: rawArtifact, state: rawState }) => {
+        const state = stateOf(rawState);
         const artifact = computerArtifactSchema.safeParse(rawArtifact);
-        if (!artifact.success) {
+        if (!artifact.success)
           throw computerSandboxError(
             "artifact_unavailable",
-            "this computer base predates the public Computers API provider; prepare it again"
+            "this computer base predates the current computer provider; prepare it again"
           );
-        }
         const base = artifact.data.base;
-        if (computerNeedsBuild(spec) && base.kind !== "captured") {
+        if (computerNeedsBuild(options.build) && base.kind !== "captured")
           throw computerSandboxError(
             "artifact_unavailable",
             `computer base ${artifact.data.key} was prepared without its build steps; prepare it again`
           );
-        }
-        const env = platformProcessEnvironment(ctx, await loadVariables(ctx, spec));
-        const client = clientFor(ctx.credentials);
-        const workspace = spec.parameters.workspace;
-        const name = await computerWorkspaceName({
-          ...ctx.session,
-          conversationWorkspace: workspace === ComputerWorkspacePolicy.Conversation
-        });
-        const workspaceId = sandboxWorkspaceId({
-          session: ctx.session,
-          workspace: sandboxWorkspaceOf[workspace]
-        });
-        const manageNetworking = await needsWorkspaceNetworking(ctx, workspaceId) || access !== SandboxAccess.Read && await needsWorkspaceNetworking(ctx, workspaceId, { access });
-        if (manageNetworking)
-          config.networking?.validateWorkspaceId?.(
-            sandboxWorkspaceId({ session: ctx.session, workspace: sandboxWorkspaceOf[workspace] })
-          );
-        const existing = await client.getComputer(name);
+        const networkingCtx = offerContextOf(ctx);
+        const client = clientFor(ctx);
+        const env = platformProcessEnvironment(ctx, {});
+        const policy = withPlatformEgressHosts(ctx, state.network);
+        const egress = computerEgressOf(policy);
+        const manageNetworking = state.networkPolicySaved || await needsWorkspaceNetworking(networkingCtx);
+        if (manageNetworking) config.networking?.validateWorkspaceId?.(ctx.sandboxId);
+        const existing = await findComputer(client, state);
         if (existing?.state === ComputerState.Error)
           throw computerSandboxError(
             "computer_gone",
-            `Computer ${existing.id} (${name}) is in the Error state. Recover it through the Computers API before retrying; its workspace is preserved.`
+            `Computer ${existing.id} (${existing.name}) is in the Error state. Recover it through the Computers API before retrying; its disk is preserved.`
           );
-        if (manageNetworking && access === SandboxAccess.Read && existing != null && existing.state !== ComputerState.Deleted && existing.state !== ComputerState.Running)
-          throw new Error("A managed Computer requires a write binding to resume networking");
-        const initialNetworkPolicy = manageNetworking && existing != null && existing.state !== ComputerState.Deleted ? networkPolicyFor(await client.getNetworkPolicy(existing.id)) : networkPolicyFor(egress);
-        if (manageNetworking && access !== SandboxAccess.Read && existing?.state === ComputerState.Running)
+        const initialNetworkPolicy = manageNetworking && existing != null ? networkPolicyFor(await client.getNetworkPolicy(existing.id)) : networkPolicyFor(egress);
+        if (manageNetworking && existing?.state === ComputerState.Running)
           await client.disableAutoResume(existing.id);
         if (manageNetworking && config.networking != null)
-          await preservePolicy({
-            ctx,
-            workspaceId: sandboxWorkspaceId({
-              session: ctx.session,
-              workspace: sandboxWorkspaceOf[workspace]
-            }),
-            policy: initialNetworkPolicy
-          });
+          await preservePolicy({ ctx: networkingCtx, policy: initialNetworkPolicy });
         let info;
-        let fresh = true;
-        if (existing != null && existing.state !== ComputerState.Deleted) {
+        let booted;
+        if (existing != null) {
           info = existing;
-          fresh = !isRunningState(existing.state);
+          booted = !isRunningState(existing.state);
           if (manageNetworking && existing.state !== ComputerState.Running)
             await client.setNetworkPolicy(
               existing.id,
@@ -1186,101 +1027,76 @@ ${step.run}`,
               { autoResume: false }
             );
           if (existing.state === ComputerState.Paused) await client.action(existing.id, "resume");
-          else if (fresh) await client.action(existing.id, "start");
+          else if (booted) await client.action(existing.id, "start");
         } else {
+          booted = true;
           const source = base.kind === "captured" ? { baseId: (await awaitBase(client, base.baseId, artifact.data.key)).id } : { imageVersionId: await readyImageVersion(client, base) };
           const body = {
-            name,
+            name: state.computerName,
             ...source,
-            ...config.machine,
+            ...machine,
             env: {},
             autoResume: !manageNetworking,
-            idleTimeoutSeconds: config.idleTimeoutSeconds ?? 15 * 60,
-            // Provider teardown owns deletion; VM-level ephemeral disks cannot be paused.
+            idleTimeoutSeconds: idleTimeoutFor(ctx),
+            // The sandbox owns deletion; VM-level ephemeral disks cannot be paused.
             ephemeral: false,
             network: manageNetworking ? { egress: ComputerEgressPolicy.None } : egress,
             tags: [
               "final-agent-sandbox",
-              `agent-binding:${ctx.session.bindingId}`,
+              `agent-sandbox:${ctx.sandboxId}`,
               "agent-runtime-attachment:v1",
               "agent-runtime-role:sandbox"
             ]
           };
           body.idlePolicy = ComputerIdlePolicy.Pause;
-          if (config.regionSlug != null) body.regionSlug = config.regionSlug;
-          const idempotencyKey = `agent-sandbox-${(await sha256Hex(`${ctx.session.bindingId}:${name}:${source.baseId ?? source.imageVersionId}:${manageNetworking}`)).slice(0, 32)}`;
+          if (region != null) body.regionSlug = region;
+          const idempotencyKey = `agent-sandbox-${(await sha256Hex(`${ctx.sandboxId}:${state.computerName}:${state.computerId ?? "first"}:${source.baseId ?? source.imageVersionId}:${manageNetworking}`)).slice(0, 32)}`;
           info = await client.createComputer(body, idempotencyKey);
         }
-        const reused = existing != null && existing.id === info.id;
-        log("computer_sandbox.started", { computerId: info.id, reused });
-        let cleanupSetup = null;
+        const fresh = existing == null;
+        log("computer_sandbox.attached", { computerId: info.id, fresh, booted });
+        let cleanup = null;
         try {
-          info = await awaitRunning(ctx, { computerId: info.id }, { timeoutMs: runningWaitMs });
+          info = await awaitComputerRunning(client, info.id, runningWaitMs);
           if (!manageNetworking) {
-            if (reused) await client.setNetworkPolicy(info.id, egress);
+            if (!fresh) await client.setNetworkPolicy(info.id, egress);
             await reportPlatformNetworkPolicy(ctx, policy);
           }
           const setup = setupSession({ client, info, env });
-          cleanupSetup = async () => setup.transport.close();
-          if (!manageNetworking || access !== SandboxAccess.Read)
-            await writePlatformFiles(ctx, setup.sandbox);
+          cleanup = async () => setup.transport.close();
+          await writePlatformFiles(ctx, setup.sandbox);
           const manager = workspaceNetworking({
-            ctx,
-            enabled: manageNetworking && access !== SandboxAccess.Read,
-            access,
+            ctx: networkingCtx,
+            enabled: manageNetworking,
             sandbox: setup.sandbox,
             client,
             info,
-            spec,
             onClose: () => setup.transport.close(),
             initialNetworkPolicy
           });
-          cleanupSetup = async () => {
+          cleanup = async () => {
             try {
               await manager?.closeOnFailure();
             } finally {
               setup.transport.close();
             }
           };
-          const servicesMarker = WORKSPACE_ROOT + "/.final-workspace-services";
-          if (fresh && manageNetworking)
-            await setup.sandbox.writeTextFile({ path: servicesMarker, content: "pending" });
           await manager?.initialize();
-          const preparationMarker = WORKSPACE_ROOT + "/.final/workspace-prepared/" + await sha256Hex(artifact.data.key);
-          let preparation = null;
-          const prepareWorkspace = () => preparation ??= (async () => {
-            await mountRepositories({
-              sandbox: setup.sandbox,
-              repositories: spec.parameters.repositories,
-              resolver: ctx.repositories,
-              log
-            });
+          const seedMarker = `${WORKSPACE_ROOT}/.final/workspace-prepared/${await sha256Hex(artifact.data.key)}`;
+          let seeding = null;
+          const seedWorkspace = () => seeding ??= (async () => {
+            if (await setup.sandbox.stat({ path: seedMarker }) != null) return;
             await materializeSandboxSeeds({
               sandbox: setup.sandbox,
               root: WORKSPACE_ROOT,
-              files: await sandboxSeedFilesForStart(ctx, artifact.data)
-            });
-            await installGuideCommands({ sandbox: setup.sandbox, template: spec.template });
-            const result = await runWorkspaceSetup({
-              sandbox: setup.sandbox,
-              template: spec.template,
-              repositories: spec.parameters.repositories,
-              log
+              files: await sandboxSeedFilesForAttach(ctx, artifact.data)
             });
-            const servicesPending = manager != null && await setup.sandbox.stat({ path: servicesMarker }) != null && await setup.sandbox.readTextFile({ path: servicesMarker }) === "pending";
-            if (fresh || servicesPending) {
-              await startServicesFor({ setup, spec, env });
-              if (manageNetworking)
-                await setup.sandbox.writeTextFile({ path: servicesMarker, content: "complete" });
-            }
-            if (manager != null)
-              await setup.sandbox.writeTextFile({ path: preparationMarker, content: "complete" });
-            return result;
+            await setup.sandbox.writeTextFile({ path: seedMarker, content: "complete" });
           })().catch((cause) => {
-            preparation = null;
+            seeding = null;
             throw cause;
           });
-          let ready = !manageNetworking || access !== SandboxAccess.Read;
+          let ready = true;
           if (manager != null) {
             try {
               await ctx.executionPolicy?.beforeExecution({
@@ -1290,310 +1106,120 @@ ${step.run}`,
               await manager.guard();
             } catch {
               log("workspace_networking.setup_deferred", {
-                provider: "computer",
+                provider: COMPUTER_PROVIDER,
                 computerId: info.id
               });
               ready = false;
             }
           }
-          const setupHash = ready ? await prepareWorkspace() : null;
-          const { handle } = await buildHandle({
-            ctx,
+          if (fresh && ready) await seedWorkspace();
+          const handle = await buildHandle({
+            ctx: { ...networkingCtx, executionPolicy: ctx.executionPolicy },
             client,
             info,
-            spec,
-            access,
             env,
+            ports: state.ports,
+            passive: false,
             networking: manager,
             networkingManaged: manageNetworking,
             closeSetup: () => setup.transport.close(),
-            beforeUse: async () => {
-              await prepareWorkspace();
-            }
+            beforeUse: fresh ? seedWorkspace : void 0
           });
           return {
             handle,
-            region: info.regionSlug ?? config.regionSlug ?? null,
+            region: info.regionSlug ?? region,
             state: {
-              version: 1,
+              ...state,
               computerId: info.id,
-              computerName: info.name,
-              workspace,
-              access,
-              guideVersionId: spec.guide?.versionId ?? null,
-              setupHash,
-              setupPending: !ready,
-              workspaceId: sandboxWorkspaceId({
-                session: ctx.session,
-                workspace: sandboxWorkspaceOf[workspace]
-              }),
               networkPolicySaved: manageNetworking
-            }
+            },
+            fresh,
+            booted
           };
         } catch (error) {
           let cause = error;
           try {
-            await cleanupSetup?.();
+            await cleanup?.();
           } catch (cleanupError) {
             cause = new AggregateError(
               [error, cleanupError],
-              "Computer setup and egress cleanup failed"
+              "Computer attach and egress cleanup failed"
             );
           }
-          if (!reused) {
+          if (fresh) {
             try {
               await client.action(info.id, "delete");
             } catch (cleanupError) {
               throw new AggregateError(
                 [cause, cleanupError],
-                `computer ${info.name} setup and cleanup failed`
+                `computer ${info.name} attach and cleanup failed`
               );
             }
           }
           throw cause;
         }
       },
-      resumePassive: async (ctx, _artifact, rawState) => {
-        const state = computerStateSchema.parse(rawState);
-        if (ctx.session.workspaceId == null && state.workspaceId != null)
-          ctx = { ...ctx, session: { ...ctx.session, workspaceId: state.workspaceId } };
-        if (state.networkPolicySaved === true && state.workspaceId != null && ctx.session.workspaceId !== state.workspaceId)
-          throw new Error("Passive workspace identity does not match retained provider state");
-        const client = clientFor(ctx.credentials);
-        const info = await client.getComputer(state.computerId);
+      attachPassive: async (ctx, { state: rawState }) => {
+        const state = stateOf(rawState);
+        const client = clientFor(ctx);
+        const info = await findComputer(client, state);
         if (info == null || info.state !== ComputerState.Running)
           throw computerSandboxError(
             "computer_not_running",
             "computer is not running for passive access"
           );
-        await awaitRunning(ctx, state, { timeoutMs: runningWaitMs });
-        const spec = await resolve(ctx.guides);
-        const env = platformProcessEnvironment(ctx, await loadVariables(ctx, spec));
-        return (await buildHandle({
-          ctx,
+        return buildHandle({
+          ctx: { ...offerContextOf(ctx), executionPolicy: ctx.executionPolicy },
           client,
-          info,
-          spec,
-          access: SandboxAccess.Read,
-          env,
-          networkingManaged: state.networkPolicySaved === true
-        })).handle;
-      },
-      resume: async (ctx, _artifact, rawState) => {
-        const state = computerStateSchema.parse(rawState);
-        if (state.networkPolicySaved === true) {
-          if (config.networking == null)
-            throw new Error("Device networking control is required before resume");
-        }
-        if (state.workspaceId != null) {
-          if (state.networkPolicySaved === true && ctx.session.workspaceId != null && ctx.session.workspaceId !== state.workspaceId)
-            throw new Error("Resume workspace identity does not match retained provider state");
-          if (ctx.session.workspaceId == null)
-            ctx = { ...ctx, session: { ...ctx.session, workspaceId: state.workspaceId } };
-        }
-        if (ctx.session.workspaceId == null)
-          ctx = {
-            ...ctx,
-            session: {
-              ...ctx.session,
-              workspaceId: sandboxWorkspaceId({
-                session: ctx.session,
-                workspace: sandboxWorkspaceOf[state.workspace]
-              })
-            }
-          };
-        const client = clientFor(ctx.credentials);
-        const workspaceId = sandboxWorkspaceId({
-          session: ctx.session,
-          workspace: sandboxWorkspaceOf[state.workspace]
+          info: await awaitComputerRunning(client, info.id, runningWaitMs),
+          env: platformProcessEnvironment(ctx, {}),
+          ports: state.ports,
+          passive: true,
+          networkingManaged: state.networkPolicySaved
         });
-        const manageNetworking = state.networkPolicySaved === true || await needsWorkspaceNetworking(ctx, workspaceId) || state.access !== SandboxAccess.Read && await needsWorkspaceNetworking(ctx, workspaceId, { access: state.access });
-        if (manageNetworking)
-          config.networking?.validateWorkspaceId?.(
-            sandboxWorkspaceId({
-              session: ctx.session,
-              workspace: sandboxWorkspaceOf[state.workspace]
-            })
-          );
-        const info = await client.getComputer(state.computerId);
-        if (info == null || info.state === ComputerState.Deleted || info.state === ComputerState.Error) {
-          throw computerSandboxError("computer_gone", `computer ${state.computerName} is gone`);
-        }
-        if (manageNetworking && state.access === SandboxAccess.Read && info.state !== ComputerState.Running)
-          throw new Error("A managed Computer requires a write binding to resume networking");
-        const initialNetworkPolicy = manageNetworking ? networkPolicyFor(await client.getNetworkPolicy(info.id)) : null;
-        if (initialNetworkPolicy != null && state.access !== SandboxAccess.Read && info.state === ComputerState.Running)
-          await client.disableAutoResume(info.id);
-        const rebooted = !isRunningState(info.state);
-        if (manageNetworking && config.networking != null && initialNetworkPolicy != null)
-          await preservePolicy({
-            ctx,
-            workspaceId: sandboxWorkspaceId({
-              session: ctx.session,
-              workspace: sandboxWorkspaceOf[state.workspace]
-            }),
-            policy: initialNetworkPolicy
-          });
-        if (manageNetworking && info.state !== ComputerState.Running)
-          await client.setNetworkPolicy(
-            info.id,
-            { egress: ComputerEgressPolicy.None },
-            { autoResume: false }
-          );
-        if (info.state === ComputerState.Paused) await client.action(info.id, "resume");
-        else if (rebooted) await client.action(info.id, "start");
-        const running = await awaitRunning(ctx, state, { timeoutMs: runningWaitMs });
-        const spec = await resolve(ctx.guides);
-        const env = platformProcessEnvironment(ctx, await loadVariables(ctx, spec));
-        if (!manageNetworking) {
-          const policy = withPlatformEgressHosts(ctx, spec.parameters.networkPolicy);
-          await client.setNetworkPolicy(running.id, computerEgressOf(policy));
-          await reportPlatformNetworkPolicy(ctx, policy);
-        }
-        const setup = setupSession({ client, info: running, env });
-        const manager = workspaceNetworking({
-          ctx,
-          enabled: manageNetworking && state.access !== SandboxAccess.Read,
-          access: state.access,
-          sandbox: setup.sandbox,
-          client,
-          info: running,
-          spec,
-          onClose: () => setup.transport.close(),
-          initialNetworkPolicy: initialNetworkPolicy ?? networkPolicyFor(egressFor(ctx, spec.parameters.networkPolicy))
-        });
-        try {
-          if (!manageNetworking || state.access !== SandboxAccess.Read)
-            await writePlatformFiles(ctx, setup.sandbox);
-          if (manageNetworking && rebooted)
-            await setup.sandbox.writeTextFile({
-              path: WORKSPACE_ROOT + "/.final-workspace-services",
-              content: "pending"
-            });
-          await manager?.initialize();
-          let preparation = null;
-          const prepareWorkspace = () => preparation ??= (async () => {
-            const artifact = state.setupPending ? computerArtifactSchema.parse(_artifact) : null;
-            const marker = artifact == null ? null : WORKSPACE_ROOT + "/.final/workspace-prepared/" + await sha256Hex(artifact.key);
-            const pending = marker != null && await setup.sandbox.stat({ path: marker }) == null;
-            if (pending && artifact != null) {
-              await mountRepositories({
-                sandbox: setup.sandbox,
-                repositories: spec.parameters.repositories,
-                resolver: ctx.repositories,
-                log
-              });
-              await materializeSandboxSeeds({
-                sandbox: setup.sandbox,
-                root: WORKSPACE_ROOT,
-                files: await sandboxSeedFilesForStart(ctx, artifact)
-              });
-            }
-            await installGuideCommands({ sandbox: setup.sandbox, template: spec.template });
-            if (pending)
-              await runWorkspaceSetup({
-                sandbox: setup.sandbox,
-                template: spec.template,
-                repositories: spec.parameters.repositories,
-                log
-              });
-            const servicesMarker = WORKSPACE_ROOT + "/.final-workspace-services";
-            const servicesPending = manageNetworking && await setup.sandbox.stat({ path: servicesMarker }) != null && await setup.sandbox.readTextFile({ path: servicesMarker }) === "pending";
-            if (rebooted || servicesPending) {
-              await startServicesFor({ setup, spec, env });
-              if (manageNetworking)
-                await setup.sandbox.writeTextFile({ path: servicesMarker, content: "complete" });
-            }
-            if (pending && marker != null)
-              await setup.sandbox.writeTextFile({ path: marker, content: "complete" });
-          })().catch((cause) => {
-            preparation = null;
-            throw cause;
-          });
-          let ready = !manageNetworking || state.access !== SandboxAccess.Read;
-          if (manager != null) {
-            try {
-              await ctx.executionPolicy?.beforeExecution({
-                operation: SandboxExecutionOperation.Run,
-                background: false
-              });
-              await manager.guard();
-            } catch {
-              log("workspace_networking.setup_deferred", {
-                provider: "computer",
-                computerId: info.id
-              });
-              ready = false;
-            }
-          }
-          if (ready) await prepareWorkspace();
-          const { handle } = await buildHandle({
-            ctx,
-            client,
-            info: running,
-            spec,
-            access: state.access,
-            env,
-            networking: manager,
-            networkingManaged: manageNetworking,
-            closeSetup: () => setup.transport.close(),
-            beforeUse: prepareWorkspace
-          });
-          return handle;
-        } catch (error) {
-          try {
-            await manager?.closeOnFailure();
-          } catch (cleanupError) {
-            throw new AggregateError(
-              [error, cleanupError],
-              "Computer resume and egress cleanup failed"
-            );
-          } finally {
-            setup.transport.close();
-          }
-          throw error;
-        }
       },
-      park: async (ctx, _artifact, rawState) => {
-        const state = computerStateSchema.parse(rawState);
-        const workspaceId = await teardownComputer({
-          ctx,
-          computerId: state.computerId,
-          computerName: state.computerName,
-          workspace: state.workspace,
-          policySaved: state.networkPolicySaved === true,
-          workspaceId: state.networkPolicySaved === true ? state.workspaceId : ctx.session.workspaceId ?? state.workspaceId,
+      // The computer pauses on its own idle policy; nothing to do.
+      detach: async (_ctx, { state }) => stateOf(state),
+      park: async (ctx, { state: rawState }) => {
+        const state = stateOf(rawState);
+        if (state.computerId == null) return state;
+        const computerId = state.computerId;
+        const networkingCtx = offerContextOf(ctx);
+        await teardownComputer({
+          ctx: networkingCtx,
+          computerId,
+          policySaved: state.networkPolicySaved,
           fence: true,
           finish: async () => {
             const failures = [];
             try {
-              await closeComputerMcp(state.computerId);
+              await closeComputerMcp(computerId);
             } catch (cause) {
               failures.push(cause);
             }
             try {
-              const client = clientFor(ctx.credentials);
+              const client = clientFor(ctx);
               let current;
               try {
-                current = await client.getComputer(state.computerId);
+                current = await client.getComputer(computerId);
               } catch (cause) {
                 failures.push(cause);
               }
               if (current !== void 0 && (current == null || hasNothingToPause(current.state))) {
                 log("computer_sandbox.park_at_rest", {
-                  computerId: state.computerId,
+                  computerId,
                   state: current?.state ?? null
                 });
               } else {
                 try {
-                  await client.action(state.computerId, "pause");
+                  await client.action(computerId, "pause");
                 } catch (error) {
                   if (!pauseMayHaveSettled(error)) throw error;
-                  const settled = await client.getComputer(state.computerId);
+                  const settled = await client.getComputer(computerId);
                   if (settled != null && settled.state !== ComputerState.Paused && !hasNothingToPause(settled.state))
                     throw error;
                   log("computer_sandbox.park_at_rest", {
-                    computerId: state.computerId,
+                    computerId,
                     state: settled?.state ?? null
                   });
                 }
@@ -1605,54 +1231,63 @@ ${step.run}`,
             if (failures.length > 1) throw new AggregateError(failures, "Computer pause failed");
           }
         });
-        const key = ctx.session.organizationId + ":" + workspaceId;
         return {
           ...state,
-          workspaceId,
-          networkPolicySaved: state.networkPolicySaved === true || savedPolicyWorkspaces.has(key)
+          networkPolicySaved: state.networkPolicySaved || savedPolicyWorkspaces.has(workspaceKey(networkingCtx))
         };
       },
-      onSessionEnd: async (ctx, _artifact, rawState, { reason }) => {
-        const state = computerStateSchema.parse(rawState);
-        const client = clientFor(ctx.credentials);
-        const finish = async () => {
-          const action = state.workspace === ComputerWorkspacePolicy.Conversation ? "stop" : "delete";
-          log("computer_sandbox.session_end", { computerId: state.computerId, reason, action });
-          try {
-            await client.action(state.computerId, action);
-          } catch (error) {
-            if (isComputersApiStatus(error, 404)) return;
-            if (!isComputersApiStatus(error, 409)) throw error;
-            const current = await client.getComputer(state.computerId);
-            const settled = current == null || current.state === ComputerState.Deleted || action === "stop" && current.state === ComputerState.Shelved;
-            if (!settled) throw error;
-            return;
-          }
-          if (action === "stop") await awaitShelved(client, state.computerId);
-        };
+      delete: async (ctx, { state: rawState }) => {
+        const state = stateOf(rawState);
+        const client = clientFor(ctx);
+        const computer = await findComputer(client, state);
+        if (computer == null) {
+          if (state.networkPolicySaved && config.networking != null)
+            await config.networking.suspend({
+              ctx: offerContextOf(ctx),
+              workspaceId: ctx.sandboxId
+            });
+          return;
+        }
         await teardownComputer({
-          ctx,
-          computerId: state.computerId,
-          computerName: state.computerName,
-          workspace: state.workspace,
-          policySaved: state.networkPolicySaved === true,
-          workspaceId: state.networkPolicySaved === true ? state.workspaceId : ctx.session.workspaceId ?? state.workspaceId,
-          fence: state.workspace === ComputerWorkspacePolicy.Conversation,
-          finish
+          ctx: offerContextOf(ctx),
+          computerId: computer.id,
+          policySaved: state.networkPolicySaved,
+          fence: false,
+          finish: async () => {
+            const failures = [];
+            try {
+              await closeComputerMcp(computer.id);
+            } catch (cause) {
+              failures.push(cause);
+            }
+            log("computer_sandbox.delete", { computerId: computer.id });
+            try {
+              await client.action(computer.id, "delete");
+            } catch (error) {
+              if (!await deletedAfterFenceError({ client, computerId: computer.id, cause: error }))
+                failures.push(error);
+            }
+            if (failures.length === 1) throw failures[0];
+            if (failures.length > 1)
+              throw new AggregateError(failures, "Computer delete or MCP cleanup failed");
+          }
         });
       }
     };
   };
   return defineSandboxProvider({
-    name: "computer",
-    stateProtocolVersion: 1,
+    name: COMPUTER_PROVIDER,
+    stateProtocolVersion: 2,
     environment
   });
 };
 export {
-  COMPUTER_SANDBOX_SPECIFIER2 as COMPUTER_SANDBOX_SPECIFIER,
-  computeComputerArtifactKey2 as computeComputerArtifactKey,
-  computerWorkspaceName,
+  COMPUTER_PROVIDER2 as COMPUTER_PROVIDER,
+  WORKSPACE_ROOT,
+  computeComputerArtifactKey,
+  computerNameFor,
+  computerNeedsBuild,
+  computerNetworkPolicyOf,
   createComputerSandboxProvider
 };
 //# sourceMappingURL=computer.mjs.map