@deepagents/context 3.1.0 → 4.1.0

package/dist/index.js

@@ -1161,6 +1161,11 @@ function getReminderRanges(metadata) {
     end: record.end
   }));
 }
+function getReminderOnceIds(message2) {
+  const meta = message2.metadata;
+  if (!isRecord(meta) || !Array.isArray(meta.onceIds)) return [];
+  return meta.onceIds.filter((id) => typeof id === "string");
+}
 function getReminderMetadataRecords(metadata) {
   const reminders = metadata?.reminders;
   if (!Array.isArray(reminders)) return [];
@@ -1174,27 +1179,6 @@ function normalizeReminderTarget(target) {
   if (target === "steer") return "steer";
   throw new Error(`Unsupported reminder target: ${String(target)}`);
 }
-function isConditionalReminderOptions(options) {
-  return options !== void 0 && "when" in options;
-}
-function isPromiseLike(value) {
-  return (typeof value === "object" || typeof value === "function") && value !== null && "then" in value && typeof value.then === "function";
-}
-function normalizeImmediateReminderText(textOrFragment) {
-  if (isFragment(textOrFragment)) {
-    return new XmlRenderer().render([textOrFragment]);
-  }
-  if (typeof textOrFragment === "string") {
-    return textOrFragment;
-  }
-  return (ctx) => {
-    const resolved = textOrFragment(ctx);
-    if (isPromiseLike(resolved)) {
-      throw new Error("Async reminder text requires a when predicate");
-    }
-    return resolved;
-  };
-}
 function normalizeConditionalReminderText(textOrFragment) {
   return isFragment(textOrFragment) ? new XmlRenderer().render([textOrFragment]) : textOrFragment;
 }
@@ -1202,7 +1186,7 @@ function isOutputAvailableToolPart(part) {
   return isStaticToolUIPart(part) && part.state === "output-available";
 }
 function isToolOutputReminderEnvelope(value) {
-  return isRecord(value) && "result" in value && typeof value.systemReminder === "string" && value.systemReminder.startsWith(SYSTEM_REMINDER_OPEN_TAG);
+  return isRecord(value) && isRecord(value.meta) && value.meta.reminder === true && "result" in value && typeof value.systemReminder === "string";
 }
 function stripTextByRanges(text, ranges) {
   if (ranges.length === 0) {
@@ -1325,7 +1309,8 @@ function applyInlineReminder(message2, value) {
   };
 }
 function applyPartReminder(message2, value) {
-  const part = { type: "text", text: value };
+  const reminderText = formatTaggedReminder(value);
+  const part = { type: "text", text: reminderText };
   message2.parts.push(part);
   const partIndex = message2.parts.length - 1;
   return {
@@ -1334,13 +1319,10 @@ function applyPartReminder(message2, value) {
     target: "user",
     partIndex,
     start: 0,
-    end: value.length,
+    end: reminderText.length,
     mode: "part"
   };
 }
-function resolveReminderText(item, ctx) {
-  return resolveReminder(item, ctx)?.text ?? "";
-}
 function normalizeReminderResolution(value) {
   if (typeof value === "string") {
     return value.trim().length === 0 ? null : { text: value };
@@ -1390,7 +1372,19 @@ function applyRemindersToToolOutput(output, texts) {
   if (texts.length === 0) return output;
   return {
     result: output === void 0 ? null : output,
-    systemReminder: formatTaggedReminder(texts.join("\n"))
+    systemReminder: formatTaggedReminder(texts.join("\n")),
+    meta: { reminder: true }
+  };
+}
+function toToolReminderModelOutput(output, projectResult) {
+  if (!isToolOutputReminderEnvelope(output)) return null;
+  const projected = projectResult(output.result);
+  return {
+    type: "json",
+    value: {
+      result: isRecord(projected) ? projected.value : projected,
+      systemReminder: output.systemReminder
+    }
   };
 }
 function mergeReminderMetadata(message2, addedReminders) {
@@ -1403,54 +1397,32 @@ function mergeReminderMetadata(message2, addedReminders) {
 function reminder(textOrFragment, options) {
   const target = normalizeReminderTarget(options?.target);
   const asPart = target === "user" ? options?.asPart ?? false : false;
-  if (isConditionalReminderOptions(options)) {
-    const text2 = normalizeConditionalReminderText(textOrFragment);
-    if (typeof text2 === "string") {
-      assertReminderText(text2);
-    }
-    return {
-      name: "reminder",
-      data: null,
-      metadata: {
-        reminder: {
-          text: text2,
-          when: options.when,
-          asPart,
-          target
-        }
-      }
-    };
-  }
-  if (target !== "user") {
+  if (options?.when === void 0 && target !== "user") {
     throw new Error(`Reminder target "${target}" requires a when predicate`);
   }
-  const text = normalizeImmediateReminderText(textOrFragment);
+  const text = normalizeConditionalReminderText(textOrFragment);
   if (typeof text === "string") {
     assertReminderText(text);
   }
   return {
-    text,
-    asPart,
-    target
+    name: "reminder",
+    data: null,
+    metadata: {
+      reminder: {
+        text,
+        when: options?.when ?? (() => true),
+        asPart,
+        target
+      }
+    }
   };
 }
-function user(content, ...reminders) {
+function user(content) {
   const message2 = typeof content === "string" ? {
     id: generateId2(),
     role: "user",
     parts: [{ type: "text", text: content }]
   } : { ...content, role: "user", parts: [...content.parts] };
-  if (reminders.length > 0) {
-    const plainText = extractPlainText(message2);
-    const added = [];
-    for (const item of reminders) {
-      const meta = applyReminderToMessage(message2, item, {
-        content: plainText
-      });
-      if (meta) added.push(meta);
-    }
-    mergeReminderMetadata(message2, added);
-  }
   return {
     id: message2.id,
     name: "user",
@@ -1466,6 +1438,16 @@ function user(content, ...reminders) {
     }
   };
 }
+function applyUserRemindersToMessage(message2, reminders) {
+  if (reminders.length === 0) return;
+  const plainText = extractPlainText(message2);
+  const added = [];
+  for (const item of reminders) {
+    const meta = applyReminderToMessage(message2, item, { content: plainText });
+    if (meta) added.push(meta);
+  }
+  mergeReminderMetadata(message2, added);
+}
 function synthesizeSteerUserMessage(text, firedAt, onceIds = []) {
   const texts = Array.isArray(text) ? text : [text];
   for (const value of texts) assertReminderText(value);
@@ -1944,12 +1926,20 @@ function wrapToolsWithOutputReminders(tools, context) {
       wrapped[name] = toolDef;
       continue;
     }
+    const originalToModelOutput = toolDef.toModelOutput;
     wrapped[name] = {
       ...toolDef,
       execute: async (input, options) => {
         const result = await execute.call(toolDef, input, options);
         if (isAsyncIterable(result)) return result;
         return context.applyToolOutputReminders(result);
+      },
+      toModelOutput: (args) => {
+        const project = (output) => originalToModelOutput ? originalToModelOutput({
+          ...args,
+          output
+        }) : defaultToolModelOutput(output);
+        return toToolReminderModelOutput(args.output, project) ?? project(args.output);
       }
     };
   }
@@ -1958,6 +1948,9 @@ function wrapToolsWithOutputReminders(tools, context) {
 function isAsyncIterable(value) {
   return typeof value === "object" && value !== null && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
 }
+function defaultToolModelOutput(output) {
+  return typeof output === "string" ? { type: "text", value: output } : { type: "json", value: output ?? null };
+}
 function agent(options) {
   return new Agent(options);
 }
@@ -2122,6 +2115,7 @@ var ChainSummaryBuilder = class {
       }
       return;
     }
+    for (const id of getReminderOnceIds(message2)) this.#firedOnceIds.add(id);
     this.#turn++;
     this.#lastMessageAt = msg.createdAt;
     this.#lastMessage = message2;
@@ -2620,12 +2614,10 @@ async function evaluateFiredReminders(configs, whenCtx) {
 var SavePipeline = class {
   #engine;
   #pending;
-  #fragments;
   #shouldBranch = true;
-  constructor(engine, pending, fragments) {
+  constructor(engine, pending) {
     this.#engine = engine;
     this.#pending = pending;
-    this.#fragments = fragments;
   }
   async applyUpdateBranching(shouldBranch) {
     this.#shouldBranch = shouldBranch;
@@ -2641,50 +2633,6 @@ var SavePipeline = class {
     }
     return this;
   }
-  /**
-   * Fold any fired `target: 'user'` conditional reminders into the last pending
-   * user message. `steer` reminders fire mid-loop via the engine's prepareStep
-   * hook and `tool-output` reminders wrap at tool-execution time, so neither is
-   * handled here — the save pipeline only carries user-message reminders.
-   */
-  async evaluateUserReminders() {
-    const configs = this.#fragments.filter(isConditionalReminder).map((fragment3) => fragment3.metadata.reminder).filter((config) => config.target === "user");
-    if (configs.length === 0) return this;
-    const fragmentIndex = this.#pending.findLastIndex(
-      (fragment3) => fragment3.name === "user"
-    );
-    if (fragmentIndex < 0) return this;
-    const fragment2 = this.#pending[fragmentIndex];
-    if (!fragment2.codec) return this;
-    const message2 = requireUserUIMessage(
-      fragment2.codec.encode(),
-      `Pending user fragment "${fragment2.name}"`
-    );
-    const chain = await this.#engine.getChainSummary();
-    const whenCtx = {
-      ...this.#engine.buildBaseWhenCtx(chain),
-      content: extractPlainText(message2),
-      currentMessage: message2,
-      lastAssistantMessage: chain.lastAssistantMessage,
-      lastAssistantMessages: chain.lastAssistantMessages
-    };
-    const matched = await evaluateFiredReminders(configs, whenCtx);
-    if (matched.length === 0) return this;
-    const reminders = matched.map((m) => ({
-      text: m.resolved.text,
-      asPart: m.config.asPart,
-      target: "user",
-      metadata: m.resolved.metadata
-    }));
-    const originalId = fragment2.id;
-    const recreated = user(
-      originalId ? { ...message2, id: originalId } : message2,
-      ...reminders
-    );
-    if (originalId) recreated.id = originalId;
-    this.#pending[fragmentIndex] = recreated;
-    return this;
-  }
   async persist() {
     let parentId = this.#engine.getActiveBranch().headMessageId;
     const now = Date.now();
@@ -3718,13 +3666,10 @@ var ContextEngine = class _ContextEngine {
     if (this.#pendingMessages.length === 0) {
       return { headMessageId: this.#branch?.headMessageId ?? void 0 };
     }
-    const pipeline = new SavePipeline(
-      this.#asSavePipelineEngine(),
-      this.#pendingMessages,
-      this.#fragments
-    );
+    const pending = this.#pendingMessages;
+    const pipeline = new SavePipeline(this.#asSavePipelineEngine(), pending);
     await pipeline.applyUpdateBranching(options?.branch ?? true);
-    await pipeline.evaluateUserReminders();
+    await this.#foldUserReminders(pending);
     const result = await pipeline.persist();
     this.#pendingMessages = [];
     return result;
@@ -3765,7 +3710,7 @@ var ContextEngine = class _ContextEngine {
       const priorStep = stepNumber >= 1 ? steps[stepNumber - 1] : void 0;
       const canFire = (priorStep?.content?.length ?? 0) > 0;
       if (canFire) {
-        const configs = this.#steerConfigs();
+        const configs = this.#remindersFor("steer");
         if (configs.length > 0) {
           const whenCtx = await this.#steerWhenCtx(session);
           const matched = await evaluateFiredReminders(configs, whenCtx);
@@ -3852,14 +3797,86 @@ var ContextEngine = class _ContextEngine {
     );
     await this.save({ branch: false });
   }
-  #steerConfigs() {
-    return this.#fragments.filter(isConditionalReminder).map((fragment2) => fragment2.metadata.reminder).filter((config) => config.target === "steer");
+  #remindersFor(target) {
+    return this.#fragments.filter(isConditionalReminder).map((fragment2) => fragment2.metadata.reminder).filter((config) => config.target === target);
+  }
+  #buildBaseWhenCtx(chain) {
+    const rawUsage = this.#chatData?.metadata?.usage;
+    const usage = isLanguageModelUsage(rawUsage) ? rawUsage : void 0;
+    const elapsed = chain.lastMessageAt !== void 0 ? Date.now() - chain.lastMessageAt : void 0;
+    const chatData = this.#chatData;
+    if (!chatData) {
+      throw new Error("ContextEngine must be initialized before reminders run");
+    }
+    return {
+      turn: chain.turn,
+      messageCount: chain.messageCount,
+      lastMessageAt: chain.lastMessageAt,
+      lastMessage: chain.lastMessage,
+      chat: chatData,
+      usage,
+      branch: this.#branchName,
+      elapsed
+    };
+  }
+  #buildWhenCtx(chain, currentMessage) {
+    return {
+      ...this.#buildBaseWhenCtx(chain),
+      content: extractPlainText(currentMessage),
+      currentMessage,
+      lastAssistantMessage: chain.lastAssistantMessage,
+      lastAssistantMessages: chain.lastAssistantMessages
+    };
+  }
+  /**
+   * `steer` reminders fire mid-loop via prepareStep and `tool-output` reminders
+   * wrap at tool-execution time, so by the time save() runs only user-target
+   * reminders remain to fold into the last pending user message.
+   */
+  async #foldUserReminders(pending) {
+    const configs = this.#remindersFor("user");
+    if (configs.length === 0) return;
+    const fragmentIndex = pending.findLastIndex(
+      (fragment3) => fragment3.name === "user"
+    );
+    if (fragmentIndex < 0) return;
+    const fragment2 = pending[fragmentIndex];
+    if (!fragment2.codec) return;
+    const message2 = requireUserUIMessage(
+      fragment2.codec.encode(),
+      `Pending user fragment "${fragment2.name}"`
+    );
+    const chain = await this.#getChainContext();
+    const matched = await evaluateFiredReminders(configs, {
+      ...this.#buildWhenCtx(chain, message2),
+      firedOnceIds: chain.firedOnceIds
+    });
+    if (matched.length === 0) return;
+    const onceIds = [...new Set(matched.flatMap((m) => m.onceIds))];
+    const reminders = matched.map((m) => ({
+      text: m.resolved.text,
+      asPart: m.config.asPart,
+      metadata: m.resolved.metadata
+    }));
+    const carrier = {
+      ...message2,
+      id: fragment2.id ?? message2.id,
+      parts: [...message2.parts]
+    };
+    if (onceIds.length > 0) {
+      carrier.metadata = {
+        ...carrier.metadata,
+        onceIds
+      };
+    }
+    applyUserRemindersToMessage(carrier, reminders);
+    pending[fragmentIndex] = user(carrier);
   }
   async #steerWhenCtx(session) {
     await this.#ensureInitialized();
     if (!session.whenBase) {
       const chain = await this.#getChainContext();
-      const base2 = this.#asSavePipelineEngine().buildBaseWhenCtx(chain);
+      const base2 = this.#buildBaseWhenCtx(chain);
       const currentMessage2 = chain.lastMessage;
       if (!currentMessage2) {
         throw new Error(
@@ -3898,9 +3915,9 @@ var ContextEngine = class _ContextEngine {
    * Evaluate `target: 'tool-output'` reminders against a tool's raw result and
    * return the (possibly wrapped) output.
    *
-   * Called by the agent's tool wrapper right after each `execute()` resolves —
-   * upstream of both the model and the store, so the next model step and the
-   * persisted chain see the exact same wrapped value (store/prompt parity).
+   * Called by the agent's tool wrapper right after each `execute()` resolves.
+   * The store keeps the wrapped value with a host-only marker; the model-facing
+   * projection strips that marker while preserving `result` + `systemReminder`.
    *
    * Returns the output unchanged when no tool-output reminder fires. Without a
    * persisted user message there is no turn context to evaluate against
@@ -3908,21 +3925,16 @@ var ContextEngine = class _ContextEngine {
    * passes through untouched.
    */
   async applyToolOutputReminders(output) {
-    const configs = this.#fragments.filter(isConditionalReminder).map((fragment2) => fragment2.metadata.reminder).filter((config) => config.target === "tool-output");
+    const configs = this.#remindersFor("tool-output");
     if (configs.length === 0) return output;
     await this.#ensureInitialized();
     const chain = await this.#getChainContext();
     const currentMessage = chain.lastMessage;
     if (!currentMessage) return output;
-    const base = this.#asSavePipelineEngine().buildBaseWhenCtx(chain);
-    const whenCtx = {
-      ...base,
-      content: extractPlainText(currentMessage),
-      currentMessage,
-      lastAssistantMessage: chain.lastAssistantMessage,
-      lastAssistantMessages: chain.lastAssistantMessages
-    };
-    const matched = await evaluateFiredReminders(configs, whenCtx);
+    const matched = await evaluateFiredReminders(
+      configs,
+      this.#buildWhenCtx(chain, currentMessage)
+    );
     if (matched.length === 0) return output;
     return applyRemindersToToolOutput(
       output,
@@ -3933,7 +3945,6 @@ var ContextEngine = class _ContextEngine {
     return {
       store: this.#store,
       chatId: this.#chatId,
-      branchName: this.#branchName,
       getActiveBranch: () => ({
         id: this.#activeBranch.id,
         headMessageId: this.#activeBranch.headMessageId
@@ -3945,29 +3956,7 @@ var ContextEngine = class _ContextEngine {
         );
         this.#activeBranch.headMessageId = headMessageId;
       },
-      rewindForUpdate: (parentId) => this.#rewindForUpdate(parentId),
-      getChainSummary: () => this.#getChainContext(),
-      buildBaseWhenCtx: (chain) => {
-        const rawUsage = this.#chatData?.metadata?.usage;
-        const usage = isLanguageModelUsage(rawUsage) ? rawUsage : void 0;
-        const elapsed = chain.lastMessageAt !== void 0 ? Date.now() - chain.lastMessageAt : void 0;
-        const chatData = this.#chatData;
-        if (!chatData) {
-          throw new Error(
-            "ContextEngine must be initialized before reminders run"
-          );
-        }
-        return {
-          turn: chain.turn,
-          messageCount: chain.messageCount,
-          lastMessageAt: chain.lastMessageAt,
-          lastMessage: chain.lastMessage,
-          chat: chatData,
-          usage,
-          branch: this.#branchName,
-          elapsed
-        };
-      }
+      rewindForUpdate: (parentId) => this.#rewindForUpdate(parentId)
     };
   }
   /**
@@ -5495,7 +5484,7 @@ function once(id) {
   return (ctx) => {
     if (ctx.firedOnceIds === void 0) {
       throw new Error(
-        `once('${id}') is only supported on target:'steer' reminders`
+        `once('${id}') is not supported on target:'tool-output' reminders`
       );
     }
     if (ctx.firedOnceIds.has(id)) return false;
@@ -6225,6 +6214,9 @@ async function createAgentOsSandbox(options = {}) {
         await os.dispose();
       } catch {
       }
+    },
+    [Symbol.asyncDispose]() {
+      return this.dispose();
     }
   };
 }
@@ -6237,57 +6229,180 @@ async function useAgentOsSandbox(options, fn) {
   }
 }
 
-// packages/context/src/lib/sandbox/bash-exception.ts
-var BashException = class extends Error {
+// packages/context/src/lib/sandbox/apple-container-sandbox.ts
+import "bash-tool";
+import spawn3 from "nano-spawn";
+import { spawn as childSpawn2 } from "node:child_process";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// packages/context/src/lib/sandbox/container-sandbox-errors.ts
+var ContainerSandboxError = class extends Error {
+  containerId;
+  constructor(message2, containerId) {
+    super(message2);
+    this.name = "ContainerSandboxError";
+    this.containerId = containerId;
+  }
 };
 
-// packages/context/src/lib/sandbox/bash-meta.ts
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
-var store = new AsyncLocalStorage2();
-function runWithBashMeta(fn) {
-  return store.run({ hidden: {} }, fn);
+// packages/context/src/lib/sandbox/apple-container-sandbox-errors.ts
+var AppleContainerSandboxError = class extends ContainerSandboxError {
+  constructor(message2, containerId) {
+    super(message2, containerId);
+    this.name = "AppleContainerSandboxError";
+  }
+};
+var ContainerServiceNotRunningError = class extends AppleContainerSandboxError {
+  constructor() {
+    super(
+      "Apple container service is not running. Start it with `container system start` (first run also needs `container system kernel set --recommended`)."
+    );
+    this.name = "ContainerServiceNotRunningError";
+  }
+};
+var AppleContainerCreationError = class extends AppleContainerSandboxError {
+  image;
+  cause;
+  constructor(message2, image, cause) {
+    super(`Failed to create container from image "${image}": ${message2}`);
+    this.name = "AppleContainerCreationError";
+    this.image = image;
+    this.cause = cause;
+  }
+};
+var AppleContainerImageBuildError = class extends AppleContainerSandboxError {
+  stderr;
+  constructor(stderr) {
+    super(`Container image build failed: ${stderr}`);
+    this.name = "AppleContainerImageBuildError";
+    this.stderr = stderr;
+  }
+};
+var AppleContainerVolumePathError = class extends AppleContainerSandboxError {
+  source;
+  containerPath;
+  reason;
+  constructor(source, containerPath, reason) {
+    super(
+      `Invalid container volume path "${source}" -> "${containerPath}": ${reason}`
+    );
+    this.name = "AppleContainerVolumePathError";
+    this.source = source;
+    this.containerPath = containerPath;
+    this.reason = reason;
+  }
+};
+var AppleContainerVolumeInspectError = class extends AppleContainerSandboxError {
+  volume;
+  reason;
+  constructor(volume, reason) {
+    super(`Failed to inspect container volume "${volume}": ${reason}`);
+    this.name = "AppleContainerVolumeInspectError";
+    this.volume = volume;
+    this.reason = reason;
+  }
+};
+var AppleContainerVolumeCreateError = class extends AppleContainerSandboxError {
+  volume;
+  reason;
+  constructor(volume, reason) {
+    super(`Failed to create container volume "${volume}": ${reason}`);
+    this.name = "AppleContainerVolumeCreateError";
+    this.volume = volume;
+    this.reason = reason;
+  }
+};
+var AppleContainerVolumeRemoveError = class extends AppleContainerSandboxError {
+  volume;
+  reason;
+  constructor(volume, reason) {
+    super(`Failed to remove container volume "${volume}": ${reason}`);
+    this.name = "AppleContainerVolumeRemoveError";
+    this.volume = volume;
+    this.reason = reason;
+  }
+};
+
+// packages/context/src/lib/sandbox/container-sandbox.ts
+import "bash-tool";
+import spawn2 from "nano-spawn";
+import { spawn as childSpawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+
+// packages/context/src/lib/sandbox/cli-process.ts
+import { Readable as Readable2 } from "node:stream";
+
+// packages/context/src/lib/sandbox/shell-quote.ts
+function shellQuote(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
 }
-function useBashMeta() {
-  const state = store.getStore();
-  if (!state) return null;
+
+// packages/context/src/lib/sandbox/cli-process.ts
+function toSandboxProcess(child, abortSignal) {
+  if (!child.stdout || !child.stderr) {
+    child.kill("SIGKILL");
+    throw new Error("exec child process is missing stdout/stderr streams");
+  }
+  const onAbort = () => child.kill("SIGKILL");
+  if (abortSignal) {
+    if (abortSignal.aborted) onAbort();
+    else abortSignal.addEventListener("abort", onAbort, { once: true });
+  }
   return {
-    setHidden(patch) {
-      state.hidden = { ...state.hidden, ...patch };
-    },
-    setReminder(text) {
-      state.reminder = text;
-    },
-    clearReminder() {
-      state.reminder = void 0;
-    }
+    stdout: Readable2.toWeb(child.stdout),
+    stderr: Readable2.toWeb(child.stderr),
+    exit: new Promise((resolve4, reject) => {
+      const settle = () => {
+        child.removeListener("exit", onExitEvent);
+        child.removeListener("error", onError);
+        abortSignal?.removeEventListener("abort", onAbort);
+      };
+      const onError = (err) => {
+        settle();
+        reject(err);
+      };
+      const onExitEvent = (code, exitSignal) => {
+        settle();
+        resolve4({ code, signal: exitSignal, success: code === 0 });
+      };
+      child.on("exit", onExitEvent);
+      child.on("error", onError);
+    })
   };
 }
-function readBashMeta() {
-  return store.getStore();
+var BASE64_WRITE_CHUNK = 32768;
+function base64WriteCommands(path5, content) {
+  const base64 = Buffer.from(content).toString("base64");
+  const quotedPath = shellQuote(path5);
+  const commands = [];
+  for (let offset = 0; offset < base64.length; offset += BASE64_WRITE_CHUNK) {
+    const chunk = base64.slice(offset, offset + BASE64_WRITE_CHUNK);
+    const redirect = offset === 0 ? ">" : ">>";
+    commands.push(
+      `printf '%s' ${shellQuote(chunk)} | base64 -d ${redirect} ${quotedPath}`
+    );
+  }
+  if (commands.length === 0) {
+    commands.push(`printf '' > ${quotedPath}`);
+  }
+  return commands;
+}
+function base64ReadCommand(path5) {
+  return `base64 ${shellQuote(path5)}`;
 }
-
-// packages/context/src/lib/sandbox/bash-tool.ts
-import { tool as tool2 } from "ai";
-import {
-  createBashTool as externalCreateBashTool
-} from "bash-tool";
-import z3 from "zod";
-
-// packages/context/src/lib/sandbox/file-changes.ts
-import { randomUUID } from "node:crypto";
-import { posix as posix2 } from "node:path";
 
 // packages/context/src/lib/sandbox/installers/installer.ts
 import "bash-tool";
 import spawn from "nano-spawn";
 
 // packages/context/src/lib/sandbox/docker-sandbox-errors.ts
-var DockerSandboxError = class extends Error {
-  containerId;
+var DockerSandboxError = class extends ContainerSandboxError {
   constructor(message2, containerId) {
-    super(message2);
+    super(message2, containerId);
     this.name = "DockerSandboxError";
-    this.containerId = containerId;
   }
 };
 var DockerNotAvailableError = class extends DockerSandboxError {
@@ -6424,9 +6539,6 @@ function isDebianBased(image) {
   const debianPatterns = ["debian", "ubuntu", "node", "python"];
   return debianPatterns.some((pattern) => lower.includes(pattern));
 }
-function shellQuote(s) {
-  return `'${s.replace(/'/g, `'\\''`)}'`;
-}
 function createInstallerContext(containerId, image) {
   const packageManager = isDebianBased(image) ? "apt-get" : "apk";
   let archPromise = null;
@@ -6513,640 +6625,757 @@ function createInstallerContext(containerId, image) {
   };
 }
 
-// packages/context/src/lib/sandbox/installers/package-manager.ts
-var PackageInstaller = class extends Installer {
-  kind;
-  packages;
-  constructor(packages) {
-    super();
-    this.packages = packages;
-    this.kind = packages.length === 0 ? "pkg:<empty>" : `pkg:${packages.join(",")}`;
-  }
-  async install(ctx) {
-    if (this.packages.length === 0) return;
-    await ctx.installPackages([...this.packages]);
-  }
-};
-function pkg(packages) {
-  return new PackageInstaller(packages);
-}
-
-// packages/context/src/lib/sandbox/installers/url-binary.ts
-var UrlBinaryInstaller = class extends Installer {
-  kind;
-  options;
-  constructor(options) {
-    super();
-    this.options = options;
-    this.kind = `url-binary:${options.name}`;
+// packages/context/src/lib/sandbox/container-sandbox.ts
+var CONTAINER_NAME_PATTERN = /^[A-Za-z0-9_.-]+$/;
+var ContainerSandboxStrategy = class {
+  context;
+  engine;
+  opts;
+  volumes;
+  name;
+  workdir;
+  createdVolumes = /* @__PURE__ */ new Set();
+  constructor(opts, engine) {
+    this.opts = opts;
+    this.engine = engine;
+    const { volumes = [], env = {}, name, workdir = "/workspace" } = opts;
+    for (const key of Object.keys(env)) {
+      if (key.length === 0 || key.includes("=")) {
+        throw this.engine.errors.generic(
+          `Invalid environment variable key: "${key}"`
+        );
+      }
+    }
+    if (name !== void 0 && !CONTAINER_NAME_PATTERN.test(name)) {
+      throw this.engine.errors.generic(
+        `Invalid container name: "${name}". Use only letters, numbers, underscore, period, or hyphen. The "sandbox-" prefix is added automatically.`
+      );
+    }
+    this.volumes = volumes;
+    this.name = name;
+    this.workdir = workdir;
   }
-  async install(ctx) {
-    const url = await resolveUrl(ctx, this.options);
-    await downloadAndInstall(
-      ctx,
-      this.options.name,
-      url,
-      this.options.binaryPath
-    );
+  async create() {
+    const image = await this.getImage();
+    let acquired;
+    try {
+      acquired = await this.acquireContainer(image);
+      this.context = { containerId: acquired.containerId, image };
+      if (!acquired.attached) {
+        await this.engine.ensureWorkdir(this.context.containerId, this.workdir);
+        await this.configure();
+      }
+    } catch (error) {
+      if (acquired && !acquired.attached) {
+        await this.stopContainer(acquired.containerId);
+      }
+      await this.cleanupCreatedVolumesAfterFailure(error);
+      throw error;
+    }
+    return this.createSandboxMethods();
   }
-};
-function urlBinary(options) {
-  return new UrlBinaryInstaller(options);
-}
-async function resolveUrl(ctx, options) {
-  if (typeof options.url === "string") return options.url;
-  const arch = await ctx.arch();
-  const archUrl = options.url[arch];
-  if (!archUrl) {
-    throw new InstallError({
-      target: options.name,
-      source: "url",
-      reason: `No URL provided for architecture "${arch}". Available: ${Object.keys(options.url).join(", ")}`,
-      containerId: ctx.containerId
-    });
+  namedContainerId() {
+    return `sandbox-${this.name}`;
   }
-  return archUrl;
-}
-async function downloadAndInstall(ctx, name, url, binaryPath, source = "url") {
-  await ctx.ensureTool("curl");
-  const isTarGz = url.endsWith(".tar.gz") || url.endsWith(".tgz");
-  const installCmd = isTarGz ? buildTarGzInstallCmd(name, url, binaryPath ?? name) : buildRawInstallCmd(name, url);
-  const result = await ctx.exec(installCmd);
-  if (result.exitCode !== 0) {
-    throw new InstallError({
-      target: name,
-      source,
-      url,
-      reason: result.stderr,
-      containerId: ctx.containerId
-    });
+  defaultContainerId() {
+    return `sandbox-${crypto.randomUUID().slice(0, 8)}`;
   }
-}
-function buildTarGzInstallCmd(name, url, binaryPathInArchive) {
-  return `
-    set -e
-    NAME=${shellQuote(name)}
-    URL=${shellQuote(url)}
-    BIN_IN_ARCHIVE=${shellQuote(binaryPathInArchive)}
-    TMPDIR=$(mktemp -d)
-    cd "$TMPDIR"
-    curl -fsSL "$URL" -o archive.tar.gz
-    tar -xzf archive.tar.gz
-    BINARY_FILE=$(find . -name "$BIN_IN_ARCHIVE" -o -name "$NAME" | head -1)
-    if [ -z "$BINARY_FILE" ]; then
-      echo "Binary not found in archive. Contents:" >&2
-      find . -type f >&2
-      exit 1
-    fi
-    chmod +x "$BINARY_FILE"
-    mv "$BINARY_FILE" "/usr/local/bin/$NAME"
-    cd /
-    rm -rf "$TMPDIR"
-  `;
-}
-function buildRawInstallCmd(name, url) {
-  return `
-    NAME=${shellQuote(name)}
-    URL=${shellQuote(url)}
-    curl -fsSL "$URL" -o "/usr/local/bin/$NAME"
-    chmod +x "/usr/local/bin/$NAME"
-  `;
-}
-
-// packages/context/src/lib/sandbox/installers/npm.ts
-var NODE_BINARIES = ["node", "npm"];
-var ENSURE_RUNTIME_HINT = "Pass `{ ensureRuntime: true }` to auto-install, or add it via `pkg([...])`.";
-var NpmInstaller = class extends Installer {
-  kind;
-  packageName;
-  options;
-  constructor(packageName, options = {}) {
-    super();
-    this.packageName = packageName;
-    this.options = options;
-    this.kind = `npm:${packageName}`;
+  async acquireContainer(image) {
+    if (!this.name) {
+      const containerId2 = this.defaultContainerId();
+      await this.prepareVolumes();
+      await this.startContainer(image, containerId2);
+      return { containerId: containerId2, attached: false };
+    }
+    const containerId = this.namedContainerId();
+    const probe = await this.inspectContainer(containerId);
+    if (probe === "running") {
+      return { containerId, attached: true };
+    }
+    if (probe === "stopped") {
+      await this.startStoppedContainer(containerId, image);
+      return { containerId, attached: true };
+    }
+    await this.prepareVolumes();
+    try {
+      await this.startContainer(image, containerId);
+      return { containerId, attached: false };
+    } catch (error) {
+      if (this.engine.isNameConflict(this.engine.errorMessage(error))) {
+        await this.cleanupCreatedVolumes();
+        const raced = await this.inspectContainer(containerId);
+        if (raced === "running") {
+          return { containerId, attached: true };
+        }
+        if (raced === "stopped") {
+          await this.startStoppedContainer(containerId, image);
+          return { containerId, attached: true };
+        }
+      }
+      throw error;
+    }
   }
-  async install(ctx) {
-    await ensureNodeRuntime(ctx, this.options.ensureRuntime ?? false);
-    const spec = this.options.version ? `${this.packageName}@${this.options.version}` : this.packageName;
-    const result = await ctx.exec(`npm install -g ${spec}`);
-    if (result.exitCode !== 0) {
-      throw new InstallError({
-        target: this.packageName,
-        source: "npm",
-        reason: result.stderr,
-        containerId: ctx.containerId
-      });
+  async startStoppedContainer(containerId, image) {
+    try {
+      await spawn2(this.engine.cli, ["start", containerId]);
+    } catch (error) {
+      const message2 = this.engineErrorMessage(error);
+      if (this.isServiceDown(message2)) {
+        throw this.engine.errors.serviceNotAvailable();
+      }
+      throw this.engine.errors.creation(message2, image, error);
     }
   }
-};
-function npm(packageName, options) {
-  return new NpmInstaller(packageName, options);
-}
-async function ensureNodeRuntime(ctx, ensure) {
-  if (ensure) {
-    await ctx.ensureTool("node", "nodejs");
-    await ctx.ensureTool("npm");
-    return;
+  async inspectContainer(containerId) {
+    try {
+      const result = await spawn2(
+        this.engine.cli,
+        this.engine.inspectArgs(containerId)
+      );
+      return this.engine.parseStatus(result.stdout.trim());
+    } catch (error) {
+      const message2 = this.engineErrorMessage(error);
+      if (this.isServiceDown(message2)) {
+        throw this.engine.errors.serviceNotAvailable();
+      }
+      if (this.engine.isMissingContainer(message2)) {
+        return "absent";
+      }
+      throw this.engine.errors.generic(
+        `Failed to inspect container "${containerId}": ${message2}`
+      );
+    }
   }
-  const check = await ctx.exec("which node && which npm");
-  if (check.exitCode !== 0) {
-    throw new MissingRuntimeError(
-      "npm",
-      NODE_BINARIES,
-      ENSURE_RUNTIME_HINT,
-      ctx.containerId
-    );
+  async prepareVolumes() {
+    this.validateVolumes();
+    for (const volume of this.volumes) {
+      if (volume.type !== "volume") {
+        continue;
+      }
+      const lifecycle = volume.lifecycle ?? "external";
+      if (lifecycle === "external") {
+        await this.inspectVolume(volume.name);
+        continue;
+      }
+      const exists = await this.volumeExists(volume.name);
+      if (exists) {
+        throw this.engine.errors.volumeCreate(
+          volume.name,
+          "managed volume already exists"
+        );
+      }
+      await this.createVolume(volume);
+      if (volume.removeOnDispose !== false) {
+        this.createdVolumes.add(volume.name);
+      }
+    }
   }
-}
-
-// packages/context/src/lib/sandbox/installers/bin.ts
-import { basename, posix } from "node:path";
-var NOT_FOUND_EXIT = 11;
-var CHMOD_FAILED_EXIT = 12;
-var BinInstaller = class extends Installer {
-  kind;
-  binary;
-  options;
-  #name;
-  #target;
-  constructor(binary, options = {}) {
-    super();
-    this.binary = binary;
-    this.options = options;
-    this.#name = resolveName(binary, options);
-    this.#target = options.target ?? posix.join("/usr/local/bin", this.#name);
-    this.kind = `bin:${this.#name}`;
+  validateVolumes() {
+    const containerPaths = /* @__PURE__ */ new Set();
+    for (const volume of this.volumes) {
+      const source = volume.type === "bind" ? volume.hostPath : volume.name;
+      if (!volume.containerPath.startsWith("/")) {
+        throw this.engine.errors.volumePath(
+          source,
+          volume.containerPath,
+          "containerPath must be absolute"
+        );
+      }
+      this.validateMountValue("containerPath", volume.containerPath, volume);
+      if (containerPaths.has(volume.containerPath)) {
+        throw this.engine.errors.volumePath(
+          source,
+          volume.containerPath,
+          "containerPath must be unique"
+        );
+      }
+      containerPaths.add(volume.containerPath);
+      if (volume.type === "bind") {
+        this.validateMountValue("hostPath", volume.hostPath, volume);
+        if (!existsSync(volume.hostPath)) {
+          throw this.engine.errors.volumePath(
+            volume.hostPath,
+            volume.containerPath,
+            "hostPath does not exist on host"
+          );
+        }
+        continue;
+      }
+      if (!/^[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(volume.name)) {
+        throw this.engine.errors.volumePath(
+          volume.name,
+          volume.containerPath,
+          "volume name must start with an alphanumeric character and contain only letters, numbers, underscore, period, or hyphen"
+        );
+      }
+      if (volume.subPath) {
+        this.validateMountValue("subPath", volume.subPath, volume);
+      }
+      if ((volume.lifecycle ?? "external") === "external") {
+        if (volume.driver || volume.driverOptions) {
+          throw this.engine.errors.volumePath(
+            volume.name,
+            volume.containerPath,
+            'driver and driverOptions require lifecycle "managed"'
+          );
+        }
+      }
+    }
   }
-  async install(ctx) {
-    const b = shellQuote(this.binary);
-    const t = shellQuote(this.#target);
-    const dir = shellQuote(posix.dirname(this.#target));
-    const result = await ctx.exec(
-      `test -f ${b} || { echo "binary not found at ${this.binary}" >&2; exit ${NOT_FOUND_EXIT}; }; if ! test -x ${b}; then chmod +x ${b} || exit ${CHMOD_FAILED_EXIT}; fi; mkdir -p ${dir} && ln -sf ${b} ${t}`
+  validateMountValue(field, value, volume) {
+    if (!value.includes(",")) {
+      return;
+    }
+    const source = volume.type === "bind" ? volume.hostPath : volume.name;
+    throw this.engine.errors.volumePath(
+      source,
+      volume.containerPath,
+      `${field} must not contain commas`
     );
-    if (result.exitCode === 0) return;
-    throw new InstallError({
-      target: this.#name,
-      source: "bin",
-      reason: explainFailure(result.exitCode, result.stderr, this.binary),
-      containerId: ctx.containerId
-    });
   }
-};
-function bin(binary, options) {
-  return new BinInstaller(binary, options);
-}
-function explainFailure(exitCode, stderr, binary) {
-  if (exitCode === NOT_FOUND_EXIT) {
-    return `binary not found at ${binary}`;
+  buildRunArgs(image, containerId) {
+    return this.engine.runArgs(image, containerId, this.opts, this.workdir);
+  }
+  async inspectVolume(name) {
+    try {
+      await spawn2(this.engine.cli, ["volume", "inspect", name]);
+    } catch (error) {
+      const reason = this.engineErrorMessage(error);
+      if (this.isServiceDown(reason)) {
+        throw this.engine.errors.serviceNotAvailable();
+      }
+      throw this.engine.errors.volumeInspect(name, reason);
+    }
+  }
+  async volumeExists(name) {
+    try {
+      await this.inspectVolume(name);
+      return true;
+    } catch (error) {
+      if (error instanceof ContainerSandboxError && this.engine.isMissingVolume(error.message)) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  async createVolume(volume) {
+    const args = this.engine.volumeCreateArgs(volume);
+    try {
+      await spawn2(this.engine.cli, args);
+    } catch (error) {
+      const reason = this.engineErrorMessage(error);
+      if (this.isServiceDown(reason)) {
+        throw this.engine.errors.serviceNotAvailable();
+      }
+      throw this.engine.errors.volumeCreate(volume.name, reason);
+    }
+  }
+  async cleanupCreatedVolumes() {
+    const volumes = [...this.createdVolumes].reverse();
+    for (const volume of volumes) {
+      try {
+        await spawn2(this.engine.cli, ["volume", "rm", volume]);
+        this.createdVolumes.delete(volume);
+      } catch (error) {
+        const reason = this.engineErrorMessage(error);
+        if (this.isServiceDown(reason)) {
+          throw this.engine.errors.serviceNotAvailable();
+        }
+        throw this.engine.errors.volumeRemove(volume, reason);
+      }
+    }
+  }
+  async cleanupCreatedVolumesAfterFailure(originalError) {
+    try {
+      await this.cleanupCreatedVolumes();
+    } catch (cleanupError) {
+      if (originalError instanceof Error) {
+        const original = originalError;
+        original.suppressed = [...original.suppressed ?? [], cleanupError];
+      }
+    }
   }
-  if (exitCode === CHMOD_FAILED_EXIT && /read-only file system/i.test(stderr)) {
-    return `${binary} is not executable and the bind mount is read-only \u2014 run \`chmod +x\` on the host, or mount with \`readOnly: false\`. (${stderr.trim()})`;
+  engineErrorMessage(error) {
+    return this.engine.errorMessage(error);
   }
-  return stderr || `bin installer failed with exit code ${exitCode}`;
-}
-function resolveName(binary, options) {
-  if (options.name) return options.name;
-  const base = basename(binary);
-  const dot = base.lastIndexOf(".");
-  return dot > 0 ? base.slice(0, dot) : base;
-}
-
-// packages/context/src/lib/sandbox/installers/pip.ts
-var PYTHON_BINARIES = ["python3", "pip3"];
-var PipInstaller = class extends Installer {
-  kind;
-  packageName;
-  options;
-  constructor(packageName, options = {}) {
-    super();
-    this.packageName = packageName;
-    this.options = options;
-    this.kind = `pip:${packageName}`;
+  isServiceDown(message2) {
+    return this.engine.isServiceDown(message2);
   }
-  async install(ctx) {
-    await ensurePythonRuntime(ctx, this.options.ensureRuntime ?? false);
-    const spec = this.options.version ? `${this.packageName}${formatVersion(this.options.version)}` : this.packageName;
-    const flags = this.options.breakSystemPackages ?? true ? "--break-system-packages" : "";
-    const result = await ctx.exec(`pip3 install ${flags} ${spec}`.trim());
-    if (result.exitCode !== 0) {
-      throw new InstallError({
-        target: this.packageName,
-        source: "pypi",
-        reason: result.stderr,
-        containerId: ctx.containerId
-      });
+  async startContainer(image, containerId) {
+    const args = this.buildRunArgs(image, containerId);
+    try {
+      await spawn2(this.engine.cli, args);
+    } catch (error) {
+      const message2 = this.engineErrorMessage(error);
+      if (this.isServiceDown(message2)) {
+        throw this.engine.errors.serviceNotAvailable();
+      }
+      throw this.engine.errors.creation(message2, image, error);
     }
   }
-};
-function pip(packageName, options) {
-  return new PipInstaller(packageName, options);
-}
-async function ensurePythonRuntime(ctx, ensure) {
-  if (ensure) {
-    const pipPackage = ctx.packageManager === "apk" ? "py3-pip" : "python3-pip";
-    await ctx.ensureTool("python3");
-    await ctx.ensureTool("pip3", pipPackage);
-    return;
-  }
-  const check = await ctx.exec("which python3 && which pip3");
-  if (check.exitCode !== 0) {
-    throw new MissingRuntimeError(
-      "pip",
-      PYTHON_BINARIES,
-      "Pass `{ ensureRuntime: true }` to auto-install, or add via `pkg([...])` (Alpine: `python3 py3-pip`; Debian: `python3 python3-pip`).",
-      ctx.containerId
-    );
+  async stopContainer(containerId) {
+    try {
+      await spawn2(this.engine.cli, ["stop", containerId]);
+    } catch {
+    }
   }
-}
-function formatVersion(version) {
-  return /^[<>=!~]/.test(version) ? version : `==${version}`;
-}
-
-// packages/context/src/lib/sandbox/installers/github-release.ts
-var GithubReleaseInstaller = class extends Installer {
-  kind;
-  options;
-  constructor(options) {
-    super();
-    this.options = options;
-    this.kind = `github-release:${options.owner}/${options.repo}@${options.version}`;
+  async exec(command, options) {
+    try {
+      const result = await spawn2(
+        this.engine.cli,
+        this.engine.execArgs(this.context.containerId, command),
+        { signal: options?.signal }
+      );
+      return {
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: 0
+      };
+    } catch (error) {
+      const err = error;
+      return {
+        stdout: err.stdout || "",
+        stderr: err.stderr || err.message || "",
+        exitCode: err.exitCode ?? 1
+      };
+    }
   }
-  async install(ctx) {
-    const arch = await ctx.arch();
-    const assetName = this.options.asset(arch);
-    const url = `https://github.com/${this.options.owner}/${this.options.repo}/releases/download/${this.options.version}/${assetName}`;
-    await downloadAndInstall(
-      ctx,
-      this.options.name,
-      url,
-      this.options.binaryPath,
-      "github-release"
+  spawnProcess(command, options) {
+    const child = childSpawn(
+      this.engine.cli,
+      this.engine.execArgs(this.context.containerId, command, options)
     );
+    return toSandboxProcess(child, options?.signal);
   }
-};
-function githubRelease(options) {
-  return new GithubReleaseInstaller(options);
-}
-
-// packages/context/src/lib/sandbox/file-changes.ts
-var REASON_HINT = {
-  "ptrace-blocked": "ptrace is denied by the sandbox runtime. Modern Docker permits it by default; on a hardened host, relax the runtime seccomp/ptrace policy (allow the ptrace syscall, or add the SYS_PTRACE capability).",
-  "strace-missing": "strace is not installed in the sandbox image. Bake `strace` into the image.",
-  "trace-unparseable": "strace ran but its output is unusable \u2014 the sandbox is likely running under emulation (e.g. amd64 via Rosetta). Use a native-architecture sandbox."
-};
-var StraceUnavailableError = class extends Error {
-  reason;
-  diagnostics;
-  constructor(reason, diagnostics) {
-    super(
-      `strace file-change tracking unavailable (${reason}): ${REASON_HINT[reason]}`
-    );
-    this.name = "StraceUnavailableError";
-    this.reason = reason;
-    this.diagnostics = diagnostics;
+  createSandboxMethods() {
+    const { containerId } = this.context;
+    const sandbox = {
+      executeCommand: async (command, options) => this.exec(command, options),
+      spawn: (command, options) => this.spawnProcess(command, options),
+      readFile: async (path5) => {
+        const result = await sandbox.executeCommand(base64ReadCommand(path5));
+        if (result.exitCode !== 0) {
+          throw new Error(`Failed to read file "${path5}": ${result.stderr}`);
+        }
+        return Buffer.from(result.stdout, "base64").toString("utf-8");
+      },
+      writeFiles: async (files) => {
+        for (const file of files) {
+          const dir = file.path.substring(0, file.path.lastIndexOf("/"));
+          if (dir) {
+            await sandbox.executeCommand(`mkdir -p ${shellQuote(dir)}`);
+          }
+          for (const command of base64WriteCommands(file.path, file.content)) {
+            const result = await sandbox.executeCommand(command);
+            if (result.exitCode !== 0) {
+              throw new Error(
+                `Failed to write file "${file.path}": ${result.stderr}`
+              );
+            }
+          }
+        }
+      },
+      dispose: async () => {
+        await this.stopContainer(containerId);
+        await this.cleanupCreatedVolumes();
+      },
+      [Symbol.asyncDispose]() {
+        return this.dispose();
+      }
+    };
+    return sandbox;
   }
 };
-var DEFAULT_TRACE_DIR = "/tmp/dat-trace";
-var STRACE_FLAGS = "-f -y -qq -e trace=%file,write,pwrite64,writev";
-function buildStraceCommand(command, traceFile, traceDir) {
-  return `mkdir -p ${shellQuote(traceDir)} 2>/dev/null; strace ${STRACE_FLAGS} -o ${shellQuote(traceFile)} -- sh -c ${shellQuote(command)}`;
-}
-function stripStraceDiagnostics(stderr) {
-  if (!stderr.includes("strace: ")) return stderr;
-  return stderr.split("\n").filter((line) => !line.startsWith("strace: ")).join("\n");
-}
-var CREATE_OR_TRUNC_FLAGS = /O_(CREAT|TRUNC)/;
-var RENAME_SYSCALLS = /* @__PURE__ */ new Set(["rename", "renameat", "renameat2"]);
-var DELETE_SYSCALLS = /* @__PURE__ */ new Set(["unlink", "unlinkat", "rmdir"]);
-var MKDIR_SYSCALLS = /* @__PURE__ */ new Set(["mkdir", "mkdirat"]);
-var LINK_SYSCALLS = /* @__PURE__ */ new Set(["link", "linkat", "symlink", "symlinkat"]);
-var OPEN_SYSCALLS = /* @__PURE__ */ new Set(["open", "openat", "openat2", "creat"]);
-var WRITE_SYSCALLS = /* @__PURE__ */ new Set([
-  "write",
-  "pwrite64",
-  "pwrite",
-  "writev",
-  "pwritev2"
-]);
-var TRUNCATE_SYSCALLS = /* @__PURE__ */ new Set(["truncate", "ftruncate"]);
-function stitchLines(raw) {
-  const pending = /* @__PURE__ */ new Map();
-  const out = [];
-  for (const original of raw.split("\n")) {
-    const line = original.trimEnd();
-    if (!line) continue;
-    const pid = line.match(/^\s*(\d+)\s+/)?.[1] ?? "0";
-    if (/<unfinished \.\.\.>\s*$/.test(line)) {
-      pending.set(pid, line.replace(/<unfinished \.\.\.>\s*$/, ""));
-      continue;
-    }
-    const resumed = line.match(/<\.\.\.\s+\S+\s+resumed>(.*)$/);
-    if (resumed) {
-      const head = pending.get(pid);
-      pending.delete(pid);
-      if (head !== void 0) out.push(head + resumed[1]);
-      continue;
-    }
-    out.push(line);
+var RuntimeStrategy = class extends ContainerSandboxStrategy {
+  image;
+  installers;
+  constructor(opts, engine, mode) {
+    super(opts, engine);
+    this.image = mode.image;
+    this.installers = mode.installers;
   }
-  return out;
-}
-function parseCall(line) {
-  const m = line.match(
-    /^\s*(?:\d+\s+)?([a-z_][a-z0-9_]*)\((.*)\)\s*=\s*(.+?)\s*$/
-  );
-  if (!m) return null;
-  const [, syscall, args, rest] = m;
-  const errnoMatch = rest.match(/^(-?\d+)\s+([A-Z][A-Z0-9_]*)/);
-  if (errnoMatch) {
-    return { syscall, args, retval: errnoMatch[1], errno: errnoMatch[2] };
+  async getImage() {
+    return this.image;
+  }
+  async configure() {
+    const ctx = this.engine.createInstallerContext(
+      this.context.containerId,
+      this.image
+    );
+    for (const installer of this.installers) {
+      await installer.install(ctx);
+    }
   }
-  return { syscall, args, retval: rest.split(/\s+/)[0] };
-}
-var STRACE_ESCAPE = {
-  n: 10,
-  t: 9,
-  r: 13,
-  v: 11,
-  f: 12,
-  '"': 34,
-  "\\": 92
 };
-function decodeStraceString(s) {
-  const bytes = [];
-  for (let i = 0; i < s.length; ) {
-    if (s[i] === "\\" && i + 1 < s.length) {
-      const octal = s.slice(i + 1, i + 4).match(/^[0-7]{1,3}/)?.[0];
-      if (octal) {
-        bytes.push(parseInt(octal, 8) & 255);
-        i += 1 + octal.length;
-        continue;
-      }
-      const mapped = STRACE_ESCAPE[s[i + 1]];
-      bytes.push(mapped ?? s.charCodeAt(i + 1));
-      i += 2;
-      continue;
+var ContainerfileStrategy = class extends ContainerSandboxStrategy {
+  dockerfile;
+  dockerContext;
+  showBuildLogs;
+  identity;
+  constructor(opts, engine, mode) {
+    super(opts, engine);
+    this.dockerfile = mode.dockerfile;
+    this.dockerContext = mode.context;
+    this.showBuildLogs = mode.showBuildLogs;
+    this.identity = mode.identity;
+  }
+  async getImage() {
+    const content = this.dockerfile.includes("\n") ? this.dockerfile : readFileSync(this.dockerfile, "utf-8");
+    const tag = `sandbox-${createHash("sha256").update(content).update(this.identity ?? "").digest("hex").slice(0, 12)}`;
+    if (!await this.engine.imageExists(tag)) {
+      await this.engine.buildImage({
+        tag,
+        dockerfile: this.dockerfile,
+        context: this.dockerContext,
+        showBuildLogs: this.showBuildLogs,
+        identity: this.identity
+      });
     }
-    const code = s.charCodeAt(i);
-    if (code < 128) bytes.push(code);
-    else for (const b of Buffer.from(s[i], "utf8")) bytes.push(b);
-    i += 1;
+    return tag;
   }
-  return Buffer.from(bytes).toString("utf8");
+  async configure() {
+  }
+};
+
+// packages/context/src/lib/sandbox/apple-container-sandbox.ts
+var CLI = "container";
+var WORKDIR = "/workspace";
+function isAppleContainerfileOptions(opts) {
+  return "dockerfile" in opts;
 }
-function quotedStrings(args) {
-  const out = [];
-  const re = /"((?:[^"\\]|\\.)*)"/g;
-  let m;
-  while ((m = re.exec(args)) !== null) {
-    out.push(decodeStraceString(m[1]));
+function buildMountArg(volume) {
+  const readOnly = volume.readOnly !== false;
+  const parts = volume.type === "bind" ? [
+    "type=bind",
+    `source=${volume.hostPath}`,
+    `target=${volume.containerPath}`
+  ] : [
+    // Named volumes mount as virtiofs; `container` has no `type=volume`.
+    "type=virtiofs",
+    `source=${volume.name}`,
+    `target=${volume.containerPath}`
+  ];
+  if (readOnly) {
+    parts.push("readonly");
   }
-  return out;
+  return parts.join(",");
 }
-function dirfdPath(args) {
-  return args.match(/^\s*(?:AT_FDCWD|-?\d+)<([^>]*)>/)?.[1] ?? "/";
+function getCliErrorMessage(error) {
+  const err = error;
+  return err.stderr?.trim() || err.stdout?.trim() || err.message || String(error);
 }
-function fdPath(args) {
-  return args.match(/^\s*-?\d+<([^>]*)>/)?.[1] ?? null;
+function safeParseArray(stdout) {
+  try {
+    const parsed = JSON.parse(stdout || "[]");
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
 }
-function openFlags(args) {
-  return args.match(/\bO_[A-Z_]+(?:\|O_[A-Z_]+)*/)?.[0] ?? "";
+function readContainerStatus(entry) {
+  const status = String(
+    entry?.status ?? ""
+  ).toLowerCase();
+  if (status === "running" || status === "booted") return "running";
+  if (status === "stopped") return "stopped";
+  throw new AppleContainerSandboxError(
+    `Container is in an unexpected state "${status}"`
+  );
 }
-function parseStraceTrace(raw, options) {
-  const dest = posix2.normalize(options.destination);
-  const traceDir = options.traceDir;
-  const traceFile = options.traceFile;
-  const now = Date.now();
-  const state = /* @__PURE__ */ new Map();
-  const renames = [];
-  const resolve4 = (dir, p) => posix2.normalize(p.startsWith("/") ? p : posix2.join(dir, p));
-  const write = (path5) => {
-    state.set(path5, "write");
-  };
-  const remove = (path5) => {
-    if (state.get(path5) === "write") state.delete(path5);
-    else state.set(path5, "delete");
-  };
-  for (const line of stitchLines(raw)) {
-    const call = parseCall(line);
-    if (!call || call.errno || call.retval === "-1") continue;
-    const { syscall, args } = call;
-    const dir = dirfdPath(args);
-    if (RENAME_SYSCALLS.has(syscall)) {
-      const strings = quotedStrings(args);
-      if (strings.length < 2) continue;
-      const from = resolve4(dir, strings[0]);
-      const to = resolve4(dir, strings[strings.length - 1]);
-      state.delete(from);
-      renames.push({ from, to });
-      continue;
-    }
-    if (DELETE_SYSCALLS.has(syscall)) {
-      const strings = quotedStrings(args);
-      if (strings.length) remove(resolve4(dir, strings[0]));
-      continue;
-    }
-    if (MKDIR_SYSCALLS.has(syscall)) {
-      const strings = quotedStrings(args);
-      if (strings.length) write(resolve4(dir, strings[0]));
-      continue;
+var appleEngine = {
+  cli: CLI,
+  runArgs(image, containerId, opts) {
+    const { memory = "1024M", cpus = 2 } = opts.resources ?? {};
+    const args = [
+      "run",
+      "--detach",
+      "--rm",
+      "--name",
+      containerId,
+      "--memory",
+      memory,
+      "--cpus",
+      String(cpus)
+    ];
+    if (opts.arch) {
+      args.push("--arch", opts.arch);
     }
-    if (LINK_SYSCALLS.has(syscall)) {
-      const strings = quotedStrings(args);
-      if (strings.length) write(resolve4(dir, strings[strings.length - 1]));
-      continue;
+    for (const [key, value] of Object.entries(opts.env ?? {})) {
+      args.push("--env", `${key}=${value}`);
     }
-    if (OPEN_SYSCALLS.has(syscall)) {
-      if (!CREATE_OR_TRUNC_FLAGS.test(openFlags(args))) continue;
-      const strings = quotedStrings(args);
-      if (strings.length) write(resolve4(dir, strings[0]));
-      continue;
+    for (const volume of opts.volumes ?? []) {
+      args.push("--mount", buildMountArg(volume));
     }
-    if (WRITE_SYSCALLS.has(syscall)) {
-      const p = fdPath(args);
-      if (p && Number(call.retval) > 0) write(posix2.normalize(p));
-      continue;
+    args.push(image);
+    if (opts.command === void 0) {
+      args.push("tail", "-f", "/dev/null");
+    } else if (opts.command !== null) {
+      args.push(...opts.command);
     }
-    if (TRUNCATE_SYSCALLS.has(syscall)) {
-      const p = fdPath(args) ?? quotedStrings(args)[0];
-      if (p) write(resolve4(dir, p));
+    return args;
+  },
+  execArgs(containerId, command, options) {
+    const flags = ["--cwd", options?.cwd || WORKDIR];
+    if (options?.env) {
+      for (const [key, value] of Object.entries(options.env)) {
+        if (key.length === 0 || key.includes("=")) {
+          throw new AppleContainerSandboxError(
+            `Invalid environment variable key: "${key}"`
+          );
+        }
+        flags.push("--env", `${key}=${value}`);
+      }
     }
-  }
-  const keep = (path5) => {
-    if (traceFile && path5 === traceFile) return false;
-    if (traceDir && (path5 === traceDir || path5.startsWith(`${traceDir}/`))) {
+    return ["exec", ...flags, containerId, "sh", "-c", command];
+  },
+  inspectArgs(containerId) {
+    return ["inspect", containerId];
+  },
+  mountArg: buildMountArg,
+  parseStatus(stdout) {
+    const entries = safeParseArray(stdout);
+    if (entries.length === 0) return "absent";
+    return readContainerStatus(entries[0]);
+  },
+  volumeCreateArgs(volume) {
+    return ["volume", "create", volume.name];
+  },
+  errorMessage: getCliErrorMessage,
+  isServiceDown(message2) {
+    return /apiserver|not running|connection refused|could not connect|xpc/i.test(
+      message2
+    );
+  },
+  isMissingContainer(message2) {
+    return /not found|no such/i.test(message2);
+  },
+  isMissingVolume(message2) {
+    return /not found|no such/i.test(message2);
+  },
+  isNameConflict(message2) {
+    return /already exists/i.test(message2);
+  },
+  async ensureWorkdir(containerId, workdir) {
+    await spawn3(CLI, ["exec", containerId, "sh", "-c", `mkdir -p ${workdir}`]);
+  },
+  defaultImage: "docker.io/library/alpine:latest",
+  createInstallerContext: createAppleInstallerContext,
+  async imageExists(tag) {
+    try {
+      await spawn3(CLI, ["image", "inspect", tag]);
+      return true;
+    } catch {
       return false;
     }
-    if (/^\/(proc|sys|dev)(\/|$)/.test(path5)) return false;
-    return dest === "/" ? true : path5 === dest || path5.startsWith(`${dest}/`);
-  };
-  const changes = [];
-  const emittedRenameTargets = /* @__PURE__ */ new Set();
-  for (const { from, to } of renames) {
-    if (!keep(to)) continue;
-    if (state.get(to) === "delete") continue;
-    changes.push({ op: "rename", path: to, from, timestamp: now });
-    emittedRenameTargets.add(to);
-  }
-  const tail = [];
-  for (const [path5, op] of state) {
-    if (emittedRenameTargets.has(path5)) continue;
-    if (keep(path5)) tail.push({ op, path: path5, timestamp: now });
+  },
+  async buildImage(spec) {
+    const archFlag = spec.identity ? ["--arch", spec.identity] : [];
+    if (spec.dockerfile.includes("\n")) {
+      const tempDir = await mkdtemp(join(tmpdir(), "sandbox-containerfile-"));
+      const dockerfilePath = join(tempDir, "Dockerfile");
+      await writeFile(dockerfilePath, spec.dockerfile);
+      try {
+        await runAppleBuild(
+          ["build", ...archFlag, "-t", spec.tag, "-f", dockerfilePath, tempDir],
+          spec.showBuildLogs
+        );
+      } finally {
+        await rm(tempDir, { recursive: true, force: true });
+      }
+      return;
+    }
+    await runAppleBuild(
+      [
+        "build",
+        ...archFlag,
+        "-t",
+        spec.tag,
+        "-f",
+        spec.dockerfile,
+        spec.context
+      ],
+      spec.showBuildLogs
+    );
+  },
+  errors: {
+    serviceNotAvailable: () => new ContainerServiceNotRunningError(),
+    creation: (message2, image, cause) => new AppleContainerCreationError(message2, image, cause),
+    generic: (message2, containerId) => new AppleContainerSandboxError(message2, containerId),
+    volumePath: (source, containerPath, reason) => new AppleContainerVolumePathError(source, containerPath, reason),
+    volumeInspect: (name, reason) => new AppleContainerVolumeInspectError(name, reason),
+    volumeCreate: (name, reason) => new AppleContainerVolumeCreateError(name, reason),
+    volumeRemove: (name, reason) => new AppleContainerVolumeRemoveError(name, reason)
   }
-  tail.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
-  changes.push(...tail);
-  return changes;
-}
-var warnOnFileChangesError = (error) => {
-  console.warn(
-    "[traceFileChanges] onFileChanges threw on spawn; isolated",
-    error
-  );
 };
-function traceFileChanges(sandbox, options) {
-  const { destination, onFileChanges } = options;
-  const onError = options.onError ?? warnOnFileChangesError;
-  const traceDir = options.traceDir ?? DEFAULT_TRACE_DIR;
-  const innerExecute = sandbox.executeCommand.bind(sandbox);
-  const innerReadFile = sandbox.readFile.bind(sandbox);
-  const innerWriteFiles = sandbox.writeFiles.bind(sandbox);
-  const dest = posix2.normalize(destination);
-  const underDestination = (path5) => dest === "/" || path5 === dest || path5.startsWith(`${dest}/`);
-  const removeTrace = (traceFile) => void innerExecute(`rm -f ${shellQuote(traceFile)}`).catch(() => {
-  });
-  const readChanges = async (traceFile) => {
+function createAppleInstallerContext(containerId, image) {
+  const packageManager = isDebianBased(image) ? "apt-get" : "apk";
+  let archPromise = null;
+  const ensuredTools = /* @__PURE__ */ new Set();
+  let aptUpdated = false;
+  const exec = async (command) => {
     try {
-      return parseStraceTrace(await innerReadFile(traceFile), {
-        destination,
-        traceFile,
-        traceDir
-      });
-    } catch {
-      return [];
-    } finally {
-      removeTrace(traceFile);
+      const result = await spawn3(CLI, [
+        "exec",
+        containerId,
+        "sh",
+        "-c",
+        command
+      ]);
+      return { stdout: result.stdout, stderr: result.stderr, exitCode: 0 };
+    } catch (error) {
+      const err = error;
+      return {
+        stdout: err.stdout ?? "",
+        stderr: err.stderr ?? err.message ?? "",
+        exitCode: err.exitCode ?? 1
+      };
     }
   };
-  const collectCommand = async (traceFile) => {
-    const changes = await readChanges(traceFile);
-    if (!changes.length) return;
-    useBashMeta()?.setHidden({ fileChanges: changes });
-    await onFileChanges?.(changes);
+  const arch = async () => {
+    if (!archPromise) {
+      const attempt = (async () => {
+        const result = await exec("uname -m");
+        if (result.exitCode !== 0) {
+          throw new AppleContainerSandboxError(
+            `Failed to detect container architecture: ${result.stderr}`,
+            containerId
+          );
+        }
+        return result.stdout.trim();
+      })();
+      archPromise = attempt.catch((err) => {
+        archPromise = null;
+        throw err;
+      });
+    }
+    return archPromise;
   };
-  const collectSpawn = async (traceFile) => {
-    const changes = await readChanges(traceFile);
-    if (!changes.length || !onFileChanges) return;
-    try {
-      await onFileChanges(changes);
-    } catch (error) {
-      onError(error);
+  const installPackages = async (packages) => {
+    if (packages.length === 0) return;
+    const quoted = packages.map(shellQuote).join(" ");
+    let cmd;
+    if (packageManager === "apt-get") {
+      cmd = aptUpdated ? `apt-get install -y ${quoted}` : `apt-get update && apt-get install -y ${quoted}`;
+    } else {
+      cmd = `apk add --no-cache ${quoted}`;
     }
+    const result = await exec(cmd);
+    if (result.exitCode !== 0) {
+      throw new PackageInstallError(
+        packages,
+        image,
+        packageManager,
+        result.stderr,
+        containerId
+      );
+    }
+    if (packageManager === "apt-get") aptUpdated = true;
   };
-  const decorated = {
-    async executeCommand(command, execOptions) {
-      const traceFile = `${traceDir}/${randomUUID()}.strace`;
-      const wrapped = buildStraceCommand(command, traceFile, traceDir);
-      let result;
-      try {
-        const raw = await innerExecute(wrapped, execOptions);
-        result = { ...raw, stderr: stripStraceDiagnostics(raw.stderr) };
-      } catch (error) {
-        removeTrace(traceFile);
-        throw error;
-      }
-      if (execOptions?.signal?.aborted) {
-        removeTrace(traceFile);
-        return result;
-      }
-      await collectCommand(traceFile);
-      return result;
-    },
-    readFile: innerReadFile,
-    // The writeFile tool mutates the filesystem outside strace's view, so
-    // observe it directly: synthesize a `write` change per file (under the
-    // observation root) and run it through onFileChanges. A throw propagates to
-    // the writeFile tool's execute (which rejects), the same gate as the bash
-    // path — except there's no CommandResult here, so throw a plain Error to
-    // reject; BashException.format() is meaningful only for bash commands.
-    writeFiles: async (files) => {
-      await innerWriteFiles(files);
-      const now = Date.now();
-      const changes = files.map(
-        (f) => posix2.normalize(
-          f.path.startsWith("/") ? f.path : posix2.join(dest, f.path)
-        )
-      ).filter(underDestination).map((path5) => ({ op: "write", path: path5, timestamp: now }));
-      if (changes.length) await onFileChanges?.(changes);
-    },
-    dispose: async () => {
-      await innerExecute(`rm -rf ${shellQuote(traceDir)}`).catch(() => {
-      });
-      await sandbox.dispose();
+  const ensureTool = async (checkName, installName) => {
+    const cacheKey = installName ?? checkName;
+    if (ensuredTools.has(cacheKey)) return;
+    const check = await exec(`which ${shellQuote(checkName)}`);
+    if (check.exitCode === 0) {
+      ensuredTools.add(cacheKey);
+      return;
     }
+    await installPackages([installName ?? checkName]);
+    ensuredTools.add(cacheKey);
+  };
+  return {
+    containerId,
+    image,
+    packageManager,
+    arch,
+    exec,
+    installPackages,
+    ensureTool
   };
-  if (sandbox.spawn) {
-    const innerSpawn = sandbox.spawn.bind(sandbox);
-    decorated.spawn = (command, spawnOptions) => {
-      const traceFile = `${traceDir}/${randomUUID()}.strace`;
-      const child = innerSpawn(
-        buildStraceCommand(command, traceFile, traceDir),
-        spawnOptions
-      );
-      const exit = (async () => {
-        try {
-          return await child.exit;
-        } finally {
-          await collectSpawn(traceFile).catch(() => {
-          });
-        }
-      })();
-      return { stdout: child.stdout, stderr: child.stderr, exit };
-    };
-  }
-  return decorated;
 }
-var PTRACE_DENIED = /strace:[^\n]*(?:PTRACE_TRACEME|ptrace|Operation not permitted|EPERM)/i;
-var STRACE_MISSING = /strace:?\s+(?:command\s+)?not found/i;
-async function selfTestStrace(sandbox) {
-  const probeDir = `/tmp/dat-strace-${randomUUID()}`;
-  const traceFile = `/tmp/dat-strace-${randomUUID()}.trace`;
-  const q = shellQuote;
-  const sequence = `mkdir -p ${q(probeDir)} && echo hi > ${q(`${probeDir}/a.txt`)} && mv ${q(`${probeDir}/a.txt`)} ${q(`${probeDir}/b.txt`)} && echo more > ${q(`${probeDir}/c.txt`)}`;
-  const wrapped = buildStraceCommand(sequence, traceFile, "/tmp");
-  let result;
-  let raw = "";
+async function runAppleBuild(args, showBuildLogs) {
   try {
-    result = await sandbox.executeCommand(wrapped);
-    raw = await sandbox.readFile(traceFile).catch(() => "");
-    const diagnostics = `exit=${result.exitCode}
-stderr=${result.stderr}
-trace[0:600]=${raw.slice(0, 600)}`;
-    if (PTRACE_DENIED.test(result.stderr)) {
-      throw new StraceUnavailableError("ptrace-blocked", diagnostics);
-    }
-    if (!raw || result.exitCode === 127 || STRACE_MISSING.test(result.stderr)) {
-      throw new StraceUnavailableError("strace-missing", diagnostics);
-    }
-    const changes = parseStraceTrace(raw, { destination: probeDir, traceFile });
-    const hasRealFdPath = raw.includes(`<${probeDir}/`);
-    const hasRename = changes.some(
-      (c) => c.op === "rename" && c.from === `${probeDir}/a.txt` && c.path === `${probeDir}/b.txt`
-    );
-    const hasWrite = changes.some((c) => c.op === "write");
-    const allUnderDir = changes.every(
-      (c) => c.path === probeDir || c.path.startsWith(`${probeDir}/`)
-    );
-    if (!hasRealFdPath || !hasRename || !hasWrite || !allUnderDir) {
-      throw new StraceUnavailableError("trace-unparseable", diagnostics);
+    if (showBuildLogs) {
+      await runStreamed(CLI, args);
+    } else {
+      await spawn3(CLI, args);
     }
+  } catch (error) {
+    throw new AppleContainerImageBuildError(getCliErrorMessage(error));
+  }
+}
+function runStreamed(command, args) {
+  return new Promise((resolve4, reject) => {
+    const child = childSpawn2(command, args, { stdio: "inherit" });
+    child.once("error", reject);
+    child.once(
+      "exit",
+      (code) => code === 0 ? resolve4() : reject(
+        new Error(
+          `${command} build exited with code ${code} (see build output above)`
+        )
+      )
+    );
+  });
+}
+async function createAppleContainerSandbox(options = {}) {
+  if (isAppleContainerfileOptions(options)) {
+    return new ContainerfileStrategy(options, appleEngine, {
+      dockerfile: options.dockerfile,
+      context: options.context ?? ".",
+      showBuildLogs: options.showBuildLogs ?? false,
+      identity: options.arch
+    }).create();
+  }
+  return new RuntimeStrategy(options, appleEngine, {
+    image: options.image ?? appleEngine.defaultImage,
+    installers: options.installers ?? []
+  }).create();
+}
+async function useAppleContainerSandbox(options, fn) {
+  const sandbox = await createAppleContainerSandbox(options);
+  try {
+    return await fn(sandbox);
   } finally {
-    void sandbox.executeCommand(`rm -rf ${q(probeDir)} ${q(traceFile)}`).catch(() => {
-    });
+    await sandbox.dispose();
   }
 }
 
+// packages/context/src/lib/sandbox/bash-exception.ts
+var BashException = class extends Error {
+};
+
+// packages/context/src/lib/sandbox/bash-meta.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+var store = new AsyncLocalStorage2();
+function runWithBashMeta(fn) {
+  return store.run({ hidden: {} }, fn);
+}
+function useBashMeta() {
+  const state = store.getStore();
+  if (!state) return null;
+  return {
+    setHidden(patch) {
+      state.hidden = { ...state.hidden, ...patch };
+    },
+    setReminder(text) {
+      state.reminder = text;
+    },
+    clearReminder() {
+      state.reminder = void 0;
+    }
+  };
+}
+function readBashMeta() {
+  return store.getStore();
+}
+
+// packages/context/src/lib/sandbox/bash-tool.ts
+import { tool as tool2 } from "ai";
+import {
+  createBashTool as externalCreateBashTool
+} from "bash-tool";
+import z3 from "zod";
+
 // packages/context/src/lib/sandbox/upload-skills.ts
 import * as path3 from "node:path";
 
@@ -7311,18 +7540,9 @@ async function createBashTool(options) {
     extraInstructions,
     sandbox: backend,
     destination,
-    onFileChanges,
-    onError,
     ...rest
   } = options;
-  const observationRoot = destination ?? "/workspace";
-  await selfTestStrace(backend);
-  const tracked = traceFileChanges(backend, {
-    destination: observationRoot,
-    onFileChanges,
-    onError
-  });
-  const sandbox = withAbortSignal(withBashExceptionCatch(tracked));
+  const sandbox = withAbortSignal(withBashExceptionCatch(backend));
   const combinedInstructions = [extraInstructions, REASONING_INSTRUCTION].filter(Boolean).join("\n\n");
   const toolkit = await externalCreateBashTool({
     ...rest,
@@ -7373,7 +7593,7 @@ async function createBashTool(options) {
   const upstreamWriteFile = toolkit.tools.writeFile;
   const originalWriteExecute = upstreamWriteFile.execute;
   const writeFileBuilder = tool2;
-  const writeFile = writeFileBuilder({
+  const writeFile2 = writeFileBuilder({
     ...upstreamWriteFile,
     execute: async (input, options2) => {
       if (!originalWriteExecute) {
@@ -7392,15 +7612,15 @@ async function createBashTool(options) {
     ...toolkit,
     sandbox,
     bash,
-    tools: { ...toolkit.tools, bash, writeFile },
+    tools: { ...toolkit.tools, bash, writeFile: writeFile2 },
     skills: skills2
   };
 }
 
 // packages/context/src/lib/sandbox/binary-bridges.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import { defineCommand } from "just-bash";
-import spawn2 from "nano-spawn";
+import spawn4 from "nano-spawn";
 import * as path4 from "path";
 function createBinaryBridges(...binaries) {
   return binaries.map((input) => {
@@ -7438,7 +7658,7 @@ function createBinaryBridges(...binaries) {
           PATH: process.env.PATH
           // Always use host PATH for binary bridges
         };
-        const result = await spawn2(binaryPath, resolvedArgs, {
+        const result = await spawn4(binaryPath, resolvedArgs, {
           cwd: realCwd,
           env: mergedEnv
         });
@@ -7487,7 +7707,7 @@ function resolveRealCwd(ctx) {
   } else {
     realCwd = process.cwd();
   }
-  if (!existsSync2(realCwd)) {
+  if (!existsSync3(realCwd)) {
     realCwd = process.cwd();
   }
   return realCwd;
@@ -7495,7 +7715,7 @@ function resolveRealCwd(ctx) {
 
 // packages/context/src/lib/sandbox/daytona-sandbox.ts
 import "bash-tool";
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID } from "node:crypto";
 var DAYTONA_DEFAULT_DESTINATION = "/home/daytona";
 var DAYTONA_EXIT_POLL_INTERVAL_MS = 250;
 var DAYTONA_EXIT_POLL_TIMEOUT_MS = 3e4;
@@ -7718,7 +7938,7 @@ function createDaytonaSandboxMethods(args) {
     async writeFiles(files) {
       try {
         for (const dir of uniqueParentDirectories(files.map((f) => f.path))) {
-          const result = await executeCommand(`mkdir -p ${shellQuote2(dir)}`);
+          const result = await executeCommand(`mkdir -p ${shellQuote(dir)}`);
           if (result.exitCode !== 0) {
             throw new DaytonaCommandError(
               `Failed to create directory "${dir}": ${result.stderr}`
@@ -7741,6 +7961,9 @@ function createDaytonaSandboxMethods(args) {
       }
     },
     async dispose() {
+    },
+    [Symbol.asyncDispose]() {
+      return this.dispose();
     }
   };
 }
@@ -7908,17 +8131,17 @@ function createTextReadable() {
   };
 }
 function buildSessionCommand(command, options) {
-  const cwdPrefix = options.cwd ? `cd ${shellQuote2(options.cwd)} && ` : "";
+  const cwdPrefix = options.cwd ? `cd ${shellQuote(options.cwd)} && ` : "";
   const env = options.env ?? {};
   const entries = Object.entries(env);
   if (entries.length === 0) {
-    return `sh -lc ${shellQuote2(`${cwdPrefix}${command}`)}`;
+    return `sh -lc ${shellQuote(`${cwdPrefix}${command}`)}`;
   }
   for (const [key] of entries) {
     validateEnvKey(key);
   }
-  const exports = entries.map(([key, value]) => `export ${key}=${shellQuote2(value)}`).join("; ");
-  return `sh -lc ${shellQuote2(`${exports}; ${cwdPrefix}${command}`)}`;
+  const exports = entries.map(([key, value]) => `export ${key}=${shellQuote(value)}`).join("; ");
+  return `sh -lc ${shellQuote(`${exports}; ${cwdPrefix}${command}`)}`;
 }
 function validateEnvKey(key) {
   if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
@@ -7928,7 +8151,7 @@ function validateEnvKey(key) {
   }
 }
 function createSessionId(kind) {
-  return `deepagents-${kind}-${randomUUID2()}`;
+  return `deepagents-${kind}-${randomUUID()}`;
 }
 function abortedCommandResult() {
   return {
@@ -7944,9 +8167,6 @@ function abortedExitInfo() {
     success: false
   };
 }
-function shellQuote2(value) {
-  return `'${value.replace(/'/g, `'\\''`)}'`;
-}
 function uniqueParentDirectories(paths) {
   const dirs = /* @__PURE__ */ new Set();
   for (const path5 of paths) {
@@ -7972,759 +8192,1045 @@ function toError(error) {
 
 // packages/context/src/lib/sandbox/docker-sandbox.ts
 import "bash-tool";
-import spawn3 from "nano-spawn";
-import { spawn as childSpawn } from "node:child_process";
-import { createHash } from "node:crypto";
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
-import { Readable as Readable2 } from "node:stream";
+import spawn5 from "nano-spawn";
+import { spawn as childSpawn3 } from "node:child_process";
+import { createHash as createHash2 } from "node:crypto";
+import { readFileSync as readFileSync3 } from "node:fs";
 function isDockerfileOptions(opts) {
   return "dockerfile" in opts;
 }
 function isComposeOptions(opts) {
   return "compose" in opts;
 }
-var CONTAINER_NAME_PATTERN = /^[A-Za-z0-9_.-]+$/;
-var DockerSandboxStrategy = class {
-  context;
-  volumes;
-  resources;
-  env;
-  name;
-  command;
-  createdVolumes = /* @__PURE__ */ new Set();
-  constructor(args = {}) {
-    const { volumes = [], resources = {}, env = {}, name, command } = args;
-    for (const key of Object.keys(env)) {
-      validateEnvKey2(key);
-    }
-    if (name !== void 0 && !CONTAINER_NAME_PATTERN.test(name)) {
-      throw new DockerSandboxError(
-        `Invalid container name: "${name}". Use only letters, numbers, underscore, period, or hyphen. The "sandbox-" prefix is added automatically.`
-      );
-    }
-    this.volumes = volumes;
-    this.resources = resources;
-    this.env = env;
-    this.name = name;
-    this.command = command;
+function dockerMountArg(volume) {
+  const readOnly = volume.readOnly !== false;
+  const parts = volume.type === "bind" ? ["type=bind", `src=${volume.hostPath}`, `dst=${volume.containerPath}`] : [
+    "type=volume",
+    `src=${volume.name}`,
+    `dst=${volume.containerPath}`,
+    ...volume.subPath ? [`volume-subpath=${volume.subPath}`] : [],
+    ...volume.noCopy ? ["volume-nocopy"] : []
+  ];
+  if (readOnly) {
+    parts.push("readonly");
   }
-  async create() {
-    const image = await this.getImage();
-    let acquired;
-    try {
-      acquired = await this.acquireContainer(image);
-      this.context = { containerId: acquired.containerId, image };
-      if (!acquired.attached) {
-        await this.configure();
+  return parts.join(",");
+}
+function runDockerBuild(args, stdin, showBuildLogs) {
+  const stdio = [
+    stdin === void 0 ? "inherit" : "pipe",
+    showBuildLogs ? "inherit" : "ignore",
+    showBuildLogs ? "inherit" : "pipe"
+  ];
+  return new Promise((resolve4, reject) => {
+    const child = childSpawn3("docker", args, { stdio });
+    let stderr = "";
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.once(
+      "error",
+      (error) => reject(new DockerfileBuildError(error.message))
+    );
+    child.once("exit", (code) => {
+      if (code === 0) {
+        resolve4();
+        return;
       }
-    } catch (error) {
-      if (acquired && !acquired.attached) {
-        await this.stopContainer(acquired.containerId);
+      reject(
+        new DockerfileBuildError(
+          showBuildLogs ? `docker build exited with code ${code} (see build output above)` : stderr || `docker build exited with code ${code}`
+        )
+      );
+    });
+    if (stdin !== void 0 && child.stdin) {
+      child.stdin.on("error", () => {
+      });
+      child.stdin.end(stdin);
+    }
+  });
+}
+var dockerEngine = {
+  cli: "docker",
+  runArgs(image, containerId, opts, workdir) {
+    const {
+      memory = "1g",
+      cpus = 2,
+      memorySwap,
+      shmSize,
+      pidsLimit,
+      ulimits = [],
+      cpusetCpus,
+      cpuShares
+    } = opts.resources ?? {};
+    const security = opts.security ?? {};
+    const network = opts.network ?? {};
+    const args = [
+      "run",
+      "-d",
+      "--rm",
+      "--name",
+      containerId,
+      "--memory",
+      memory,
+      "--cpus",
+      String(cpus),
+      "-w",
+      workdir
+    ];
+    if (memorySwap) {
+      args.push("--memory-swap", memorySwap);
+    }
+    if (shmSize) {
+      args.push("--shm-size", shmSize);
+    }
+    if (pidsLimit !== void 0) {
+      args.push("--pids-limit", String(pidsLimit));
+    }
+    for (const ulimit of ulimits) {
+      args.push("--ulimit", ulimit);
+    }
+    if (cpusetCpus) {
+      args.push("--cpuset-cpus", cpusetCpus);
+    }
+    if (cpuShares !== void 0) {
+      args.push("--cpu-shares", String(cpuShares));
+    }
+    if (opts.platform) {
+      args.push("--platform", opts.platform);
+    }
+    if (opts.runtime) {
+      args.push("--runtime", opts.runtime);
+    }
+    for (const cap of security.capDrop ?? []) {
+      args.push("--cap-drop", cap);
+    }
+    for (const cap of security.capAdd ?? []) {
+      args.push("--cap-add", cap);
+    }
+    if (security.readOnly) {
+      args.push("--read-only");
+    }
+    if (security.user) {
+      args.push("--user", security.user);
+    }
+    for (const mount of security.tmpfs ?? []) {
+      args.push("--tmpfs", mount);
+    }
+    for (const opt of security.securityOpt ?? []) {
+      args.push("--security-opt", opt);
+    }
+    if (network.mode) {
+      args.push("--network", network.mode);
+    }
+    for (const port of network.publish ?? []) {
+      args.push("--publish", port);
+    }
+    for (const server of network.dns ?? []) {
+      args.push("--dns", server);
+    }
+    for (const host of network.addHost ?? []) {
+      args.push("--add-host", host);
+    }
+    if (network.hostname) {
+      args.push("--hostname", network.hostname);
+    }
+    if (opts.gpus) {
+      args.push("--gpus", opts.gpus);
+    }
+    for (const device of opts.devices ?? []) {
+      args.push("--device", device);
+    }
+    if (opts.init) {
+      args.push("--init");
+    }
+    for (const [key, value] of Object.entries(opts.labels ?? {})) {
+      args.push("--label", `${key}=${value}`);
+    }
+    for (const [key, value] of Object.entries(opts.sysctls ?? {})) {
+      args.push("--sysctl", `${key}=${value}`);
+    }
+    if (opts.entrypoint) {
+      args.push("--entrypoint", opts.entrypoint);
+    }
+    for (const [key, value] of Object.entries(opts.env ?? {})) {
+      args.push("-e", `${key}=${value}`);
+    }
+    for (const volume of opts.volumes ?? []) {
+      args.push("--mount", dockerMountArg(volume));
+    }
+    args.push(image);
+    if (opts.command === void 0) {
+      args.push("tail", "-f", "/dev/null");
+    } else if (opts.command !== null) {
+      args.push(...opts.command);
+    }
+    return args;
+  },
+  execArgs(containerId, command, options) {
+    const flags = [];
+    if (options?.cwd) {
+      flags.push("-w", options.cwd);
+    }
+    if (options?.env) {
+      for (const [key, value] of Object.entries(options.env)) {
+        if (key.length === 0 || key.includes("=")) {
+          throw new DockerSandboxError(
+            `Invalid environment variable key: "${key}"`
+          );
+        }
+        flags.push("-e", `${key}=${value}`);
       }
-      await this.cleanupCreatedVolumesAfterFailure(error);
-      throw error;
     }
-    return this.createSandboxMethods();
+    return ["exec", ...flags, containerId, "sh", "-c", command];
+  },
+  inspectArgs(containerId) {
+    return [
+      "container",
+      "inspect",
+      "--format",
+      "{{.State.Status}}",
+      containerId
+    ];
+  },
+  mountArg: dockerMountArg,
+  parseStatus(status) {
+    return status === "running" ? "running" : "stopped";
+  },
+  volumeCreateArgs(volume) {
+    const args = ["volume", "create"];
+    if (volume.driver) {
+      args.push("--driver", volume.driver);
+    }
+    for (const [key, value] of Object.entries(volume.driverOptions ?? {})) {
+      args.push("--opt", `${key}=${value}`);
+    }
+    args.push(volume.name);
+    return args;
+  },
+  errorMessage(error) {
+    const err = error;
+    return err.stderr || err.stdout || err.message || String(error);
+  },
+  isServiceDown(message2) {
+    return message2.includes("Cannot connect") || message2.includes("docker daemon");
+  },
+  isMissingContainer(message2) {
+    return message2.toLowerCase().includes("no such container");
+  },
+  isMissingVolume(message2) {
+    return message2.toLowerCase().includes("no such volume");
+  },
+  isNameConflict(message2) {
+    return message2.toLowerCase().includes("is already in use by container");
+  },
+  async ensureWorkdir() {
+  },
+  defaultImage: "alpine:latest",
+  createInstallerContext,
+  async imageExists(tag) {
+    try {
+      await spawn5("docker", ["image", "inspect", tag]);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  async buildImage(spec) {
+    const inline = spec.dockerfile.includes("\n");
+    const args = [
+      "build",
+      ...spec.identity ? ["--platform", spec.identity] : [],
+      "-t",
+      spec.tag,
+      "-f",
+      inline ? "-" : spec.dockerfile,
+      spec.context
+    ];
+    await runDockerBuild(
+      args,
+      inline ? spec.dockerfile : void 0,
+      spec.showBuildLogs
+    );
+  },
+  errors: {
+    serviceNotAvailable: () => new DockerNotAvailableError(),
+    creation: (message2, image, cause) => new ContainerCreationError(message2, image, cause),
+    generic: (message2, containerId) => new DockerSandboxError(message2, containerId),
+    volumePath: (source, containerPath, reason) => new VolumePathError(source, containerPath, reason),
+    volumeInspect: (name, reason) => new VolumeInspectError(name, reason),
+    volumeCreate: (name, reason) => new VolumeCreateError(name, reason),
+    volumeRemove: (name, reason) => new VolumeRemoveError(name, reason)
   }
-  namedContainerId() {
-    return `sandbox-${this.name}`;
+};
+function validateEnvKey2(key) {
+  if (key.length === 0 || key.includes("=")) {
+    throw new DockerSandboxError(`Invalid environment variable key: "${key}"`);
   }
-  defaultContainerId() {
-    return `sandbox-${crypto.randomUUID().slice(0, 8)}`;
+}
+function buildDockerExecFlags(options) {
+  const flags = [];
+  if (options?.cwd) {
+    flags.push("-w", options.cwd);
   }
-  async acquireContainer(image) {
-    if (!this.name) {
-      const containerId2 = this.defaultContainerId();
-      await this.prepareVolumes();
-      await this.startContainer(image, containerId2);
-      return { containerId: containerId2, attached: false };
-    }
-    const containerId = this.namedContainerId();
-    const probe = await this.inspectContainer(containerId);
-    if (probe === "running") {
-      return { containerId, attached: true };
-    }
-    if (probe === "stopped") {
-      await this.startStoppedContainer(containerId, image);
-      return { containerId, attached: true };
+  if (options?.env) {
+    for (const [key, value] of Object.entries(options.env)) {
+      validateEnvKey2(key);
+      flags.push("-e", `${key}=${value}`);
     }
-    await this.prepareVolumes();
+  }
+  return flags;
+}
+var ComposeStrategy = class extends ContainerSandboxStrategy {
+  projectName;
+  composeFile;
+  service;
+  constructor(args) {
+    super({ resources: args.resources }, dockerEngine);
+    this.composeFile = args.compose;
+    this.service = args.service;
+    this.projectName = this.computeProjectName();
+  }
+  computeProjectName() {
+    const content = readFileSync3(this.composeFile, "utf-8");
+    const hash = createHash2("sha256").update(content).digest("hex").slice(0, 8);
+    return `sandbox-${hash}`;
+  }
+  async getImage() {
+    return "";
+  }
+  async startContainer(_image, _containerId) {
     try {
-      await this.startContainer(image, containerId);
-      return { containerId, attached: false };
+      await spawn5("docker", [
+        "compose",
+        "-f",
+        this.composeFile,
+        "-p",
+        this.projectName,
+        "up",
+        "-d"
+      ]);
     } catch (error) {
-      if (error instanceof ContainerCreationError && this.isNameConflictError(error.message)) {
-        await this.cleanupCreatedVolumes();
-        const raced = await this.inspectContainer(containerId);
-        if (raced === "running") {
-          return { containerId, attached: true };
-        }
-        if (raced === "stopped") {
-          await this.startStoppedContainer(containerId, image);
-          return { containerId, attached: true };
-        }
+      const err = error;
+      if (err.stderr?.includes("Cannot connect")) {
+        throw this.engine.errors.serviceNotAvailable();
       }
-      throw error;
+      throw new ComposeStartError(this.composeFile, err.stderr || err.message);
     }
   }
-  async startStoppedContainer(containerId, image) {
+  defaultContainerId() {
+    return this.projectName;
+  }
+  async configure() {
+  }
+  async exec(command, options) {
     try {
-      await spawn3("docker", ["start", containerId]);
+      const result = await spawn5(
+        "docker",
+        [
+          "compose",
+          "-f",
+          this.composeFile,
+          "-p",
+          this.projectName,
+          "exec",
+          "-T",
+          this.service,
+          "sh",
+          "-c",
+          command
+        ],
+        { signal: options?.signal }
+      );
+      return { stdout: result.stdout, stderr: result.stderr, exitCode: 0 };
     } catch (error) {
-      const message2 = this.getDockerErrorMessage(error);
-      if (this.isDockerUnavailableError(message2)) {
-        throw new DockerNotAvailableError();
-      }
-      throw new ContainerCreationError(message2, image, error);
+      const err = error;
+      return {
+        stdout: err.stdout || "",
+        stderr: err.stderr || err.message || "",
+        exitCode: err.exitCode ?? 1
+      };
     }
   }
-  async inspectContainer(containerId) {
+  spawnProcess(command, options) {
+    const child = childSpawn3("docker", [
+      "compose",
+      "-f",
+      this.composeFile,
+      "-p",
+      this.projectName,
+      "exec",
+      "-T",
+      ...buildDockerExecFlags(options),
+      this.service,
+      "sh",
+      "-c",
+      command
+    ]);
+    return toSandboxProcess(child, options?.signal);
+  }
+  async stopContainer(_containerId) {
     try {
-      const result = await spawn3("docker", [
-        "container",
-        "inspect",
-        "--format",
-        "{{.State.Status}}",
-        containerId
+      await spawn5("docker", [
+        "compose",
+        "-f",
+        this.composeFile,
+        "-p",
+        this.projectName,
+        "down"
       ]);
-      const status = result.stdout.trim();
-      return status === "running" ? "running" : "stopped";
-    } catch (error) {
-      const message2 = this.getDockerErrorMessage(error);
-      if (this.isDockerUnavailableError(message2)) {
-        throw new DockerNotAvailableError();
-      }
-      if (this.isMissingContainerError(message2)) {
-        return "absent";
-      }
-      throw new DockerSandboxError(
-        `Failed to inspect container "${containerId}": ${message2}`
-      );
+    } catch {
     }
   }
-  isMissingContainerError(message2) {
-    return message2.toLowerCase().includes("no such container");
+};
+async function createDockerSandbox(options = {}) {
+  if (isComposeOptions(options)) {
+    return new ComposeStrategy({
+      compose: options.compose,
+      service: options.service,
+      resources: options.resources
+    }).create();
   }
-  isNameConflictError(message2) {
-    return message2.toLowerCase().includes("is already in use by container");
+  if (isDockerfileOptions(options)) {
+    return new ContainerfileStrategy(options, dockerEngine, {
+      dockerfile: options.dockerfile,
+      context: options.context ?? ".",
+      showBuildLogs: options.showBuildLogs ?? false,
+      identity: options.platform
+    }).create();
   }
-  async prepareVolumes() {
-    this.validateVolumes();
-    for (const volume of this.volumes) {
-      if (volume.type !== "volume") {
-        continue;
-      }
-      const lifecycle = volume.lifecycle ?? "external";
-      if (lifecycle === "external") {
-        await this.inspectVolume(volume.name);
-        continue;
-      }
-      const exists = await this.volumeExists(volume.name);
-      if (exists) {
-        throw new VolumeCreateError(
-          volume.name,
-          "managed volume already exists"
-        );
-      }
-      await this.createVolume(volume);
-      if (volume.removeOnDispose !== false) {
-        this.createdVolumes.add(volume.name);
-      }
-    }
+  return new RuntimeStrategy(options, dockerEngine, {
+    image: options.image ?? dockerEngine.defaultImage,
+    installers: options.installers ?? []
+  }).create();
+}
+async function useSandbox(options, fn) {
+  const sandbox = await createDockerSandbox(options);
+  try {
+    return await fn(sandbox);
+  } finally {
+    await sandbox.dispose();
   }
-  validateVolumes() {
-    const containerPaths = /* @__PURE__ */ new Set();
-    for (const volume of this.volumes) {
-      const source = volume.type === "bind" ? volume.hostPath : volume.name;
-      if (!volume.containerPath.startsWith("/")) {
-        throw new VolumePathError(
-          source,
-          volume.containerPath,
-          "containerPath must be absolute"
-        );
-      }
-      this.validateMountValue("containerPath", volume.containerPath, volume);
-      if (containerPaths.has(volume.containerPath)) {
-        throw new VolumePathError(
-          source,
-          volume.containerPath,
-          "containerPath must be unique"
-        );
-      }
-      containerPaths.add(volume.containerPath);
-      if (volume.type === "bind") {
-        this.validateMountValue("hostPath", volume.hostPath, volume);
-        if (!existsSync3(volume.hostPath)) {
-          throw new VolumePathError(
-            volume.hostPath,
-            volume.containerPath,
-            "hostPath does not exist on host"
-          );
-        }
-        continue;
-      }
-      if (!/^[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(volume.name)) {
-        throw new VolumePathError(
-          volume.name,
-          volume.containerPath,
-          "volume name must start with an alphanumeric character and contain only letters, numbers, underscore, period, or hyphen"
-        );
-      }
-      if (volume.subPath) {
-        this.validateMountValue("subPath", volume.subPath, volume);
-      }
-      if ((volume.lifecycle ?? "external") === "external") {
-        if (volume.driver || volume.driverOptions) {
-          throw new VolumePathError(
-            volume.name,
-            volume.containerPath,
-            'driver and driverOptions require lifecycle "managed"'
-          );
-        }
-      }
+}
+
+// packages/context/src/lib/sandbox/strace/file-changes.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { posix as posix2 } from "node:path";
+
+// packages/context/src/lib/sandbox/strace/index.ts
+import spawn6 from "nano-spawn";
+import { posix } from "node:path";
+var STRACE_FLAGS = "-f -y -qq -e trace=%file,write,pwrite64,writev";
+function buildStraceCommand(command, traceFile, traceDir) {
+  return `mkdir -p ${shellQuote(traceDir)} 2>/dev/null; strace ${STRACE_FLAGS} -o ${shellQuote(traceFile)} -- sh -c ${shellQuote(command)}`;
+}
+function buildTracedCommand(command, traceFile, traceDir, sentinel) {
+  return `mkdir -p ${shellQuote(traceDir)} 2>/dev/null; strace ${STRACE_FLAGS} -o ${shellQuote(traceFile)} -- sh -c ${shellQuote(command)}; __dat_rc=$?; printf '\\n%s\\n' ${shellQuote(sentinel)}; base64 ${shellQuote(traceFile)} 2>/dev/null; rm -f ${shellQuote(traceFile)} 2>/dev/null; exit $__dat_rc`;
+}
+function splitTracedOutput(stdout, sentinel) {
+  const marker = `
+${sentinel}
+`;
+  const at = stdout.indexOf(marker);
+  if (at === -1) return { stdout, trace: "" };
+  const base64 = stdout.slice(at + marker.length);
+  return {
+    stdout: stdout.slice(0, at),
+    trace: base64 ? Buffer.from(base64, "base64").toString("utf8") : ""
+  };
+}
+var CREATE_OR_TRUNC_FLAGS = /O_(CREAT|TRUNC)/;
+var RENAME_SYSCALLS = /* @__PURE__ */ new Set(["rename", "renameat", "renameat2"]);
+var DELETE_SYSCALLS = /* @__PURE__ */ new Set(["unlink", "unlinkat", "rmdir"]);
+var MKDIR_SYSCALLS = /* @__PURE__ */ new Set(["mkdir", "mkdirat"]);
+var LINK_SYSCALLS = /* @__PURE__ */ new Set(["link", "linkat", "symlink", "symlinkat"]);
+var OPEN_SYSCALLS = /* @__PURE__ */ new Set(["open", "openat", "openat2", "creat"]);
+var WRITE_SYSCALLS = /* @__PURE__ */ new Set([
+  "write",
+  "pwrite64",
+  "pwrite",
+  "writev",
+  "pwritev2"
+]);
+var TRUNCATE_SYSCALLS = /* @__PURE__ */ new Set(["truncate", "ftruncate"]);
+function stitchLines(raw) {
+  const pending = /* @__PURE__ */ new Map();
+  const out = [];
+  for (const original of raw.split("\n")) {
+    const line = original.trimEnd();
+    if (!line) continue;
+    const pid = line.match(/^\s*(\d+)\s+/)?.[1] ?? "0";
+    if (/<unfinished \.\.\.>\s*$/.test(line)) {
+      pending.set(pid, line.replace(/<unfinished \.\.\.>\s*$/, ""));
+      continue;
+    }
+    const resumed = line.match(/<\.\.\.\s+\S+\s+resumed>(.*)$/);
+    if (resumed) {
+      const head = pending.get(pid);
+      pending.delete(pid);
+      if (head !== void 0) out.push(head + resumed[1]);
+      continue;
     }
+    out.push(line);
   }
-  validateMountValue(field, value, volume) {
-    if (!value.includes(",")) {
-      return;
+  return out;
+}
+function parseCall(line) {
+  const m = line.match(
+    /^\s*(?:\d+\s+)?([a-z_][a-z0-9_]*)\((.*)\)\s*=\s*(.+?)\s*$/
+  );
+  if (!m) return null;
+  const [, syscall, args, rest] = m;
+  const errnoMatch = rest.match(/^(-?\d+)\s+([A-Z][A-Z0-9_]*)/);
+  if (errnoMatch) {
+    return { syscall, args, retval: errnoMatch[1], errno: errnoMatch[2] };
+  }
+  return { syscall, args, retval: rest.split(/\s+/)[0] };
+}
+var STRACE_ESCAPE = {
+  n: 10,
+  t: 9,
+  r: 13,
+  v: 11,
+  f: 12,
+  '"': 34,
+  "\\": 92
+};
+function decodeStraceString(s) {
+  const bytes = [];
+  for (let i = 0; i < s.length; ) {
+    if (s[i] === "\\" && i + 1 < s.length) {
+      const octal = s.slice(i + 1, i + 4).match(/^[0-7]{1,3}/)?.[0];
+      if (octal) {
+        bytes.push(parseInt(octal, 8) & 255);
+        i += 1 + octal.length;
+        continue;
+      }
+      const mapped = STRACE_ESCAPE[s[i + 1]];
+      bytes.push(mapped ?? s.charCodeAt(i + 1));
+      i += 2;
+      continue;
     }
-    const source = volume.type === "bind" ? volume.hostPath : volume.name;
-    throw new VolumePathError(
-      source,
-      volume.containerPath,
-      `${field} must not contain commas`
-    );
+    const code = s.charCodeAt(i);
+    if (code < 128) bytes.push(code);
+    else for (const b of Buffer.from(s[i], "utf8")) bytes.push(b);
+    i += 1;
   }
-  buildDockerArgs(image, containerId) {
-    const { memory = "1g", cpus = 2 } = this.resources;
-    const args = [
-      "run",
-      "-d",
-      "--rm",
-      "--name",
-      containerId,
-      `--memory=${memory}`,
-      `--cpus=${cpus}`,
-      "-w",
-      "/workspace"
-    ];
-    for (const [key, value] of Object.entries(this.env)) {
-      args.push("-e", `${key}=${value}`);
-    }
-    for (const volume of this.volumes) {
-      args.push("--mount", this.buildVolumeMountArg(volume));
-    }
-    args.push(image);
-    if (this.command === void 0) {
-      args.push("tail", "-f", "/dev/null");
-    } else if (this.command !== null) {
-      args.push(...this.command);
-    }
-    return args;
+  return Buffer.from(bytes).toString("utf8");
+}
+function quotedStrings(args) {
+  const out = [];
+  const re = /"((?:[^"\\]|\\.)*)"/g;
+  let m;
+  while ((m = re.exec(args)) !== null) {
+    out.push(decodeStraceString(m[1]));
   }
-  buildVolumeMountArg(volume) {
-    const readOnly = volume.readOnly !== false;
-    const parts = volume.type === "bind" ? ["type=bind", `src=${volume.hostPath}`, `dst=${volume.containerPath}`] : [
-      "type=volume",
-      `src=${volume.name}`,
-      `dst=${volume.containerPath}`,
-      ...volume.subPath ? [`volume-subpath=${volume.subPath}`] : [],
-      ...volume.noCopy ? ["volume-nocopy"] : []
-    ];
-    if (readOnly) {
-      parts.push("readonly");
+  return out;
+}
+function dirfdPath(args) {
+  return args.match(/^\s*(?:AT_FDCWD|-?\d+)<([^>]*)>/)?.[1] ?? "/";
+}
+function fdPath(args) {
+  return args.match(/^\s*-?\d+<([^>]*)>/)?.[1] ?? null;
+}
+function openFlags(args) {
+  return args.match(/\bO_[A-Z_]+(?:\|O_[A-Z_]+)*/)?.[0] ?? "";
+}
+function matchesGlobs(path5, include, exclude) {
+  return include.some((glob) => posix.matchesGlob(path5, glob)) && !exclude?.some((glob) => posix.matchesGlob(path5, glob));
+}
+function parseStraceTrace(raw, options) {
+  const { include, exclude, traceDir, traceFile } = options;
+  const now = Date.now();
+  const state = /* @__PURE__ */ new Map();
+  const renames = [];
+  const resolve4 = (dir, p) => posix.normalize(p.startsWith("/") ? p : posix.join(dir, p));
+  const write = (path5) => {
+    state.set(path5, "write");
+  };
+  const remove = (path5) => {
+    if (state.get(path5) === "write") state.delete(path5);
+    else state.set(path5, "delete");
+  };
+  for (const line of stitchLines(raw)) {
+    const call = parseCall(line);
+    if (!call || call.errno || call.retval === "-1") continue;
+    const { syscall, args } = call;
+    const dir = dirfdPath(args);
+    if (RENAME_SYSCALLS.has(syscall)) {
+      const strings = quotedStrings(args);
+      if (strings.length < 2) continue;
+      const from = resolve4(dir, strings[0]);
+      const to = resolve4(dir, strings[strings.length - 1]);
+      state.delete(from);
+      renames.push({ from, to });
+      continue;
     }
-    return parts.join(",");
-  }
-  async inspectVolume(name) {
-    try {
-      await spawn3("docker", ["volume", "inspect", name]);
-    } catch (error) {
-      const reason = this.getDockerErrorMessage(error);
-      if (this.isDockerUnavailableError(reason)) {
-        throw new DockerNotAvailableError();
-      }
-      throw new VolumeInspectError(name, reason);
+    if (DELETE_SYSCALLS.has(syscall)) {
+      const strings = quotedStrings(args);
+      if (strings.length) remove(resolve4(dir, strings[0]));
+      continue;
     }
-  }
-  async volumeExists(name) {
-    try {
-      await this.inspectVolume(name);
-      return true;
-    } catch (error) {
-      if (error instanceof VolumeInspectError) {
-        if (this.isMissingVolumeInspectError(error.reason)) {
-          return false;
-        }
-        throw error;
-      }
-      throw error;
+    if (MKDIR_SYSCALLS.has(syscall)) {
+      const strings = quotedStrings(args);
+      if (strings.length) write(resolve4(dir, strings[0]));
+      continue;
     }
-  }
-  async createVolume(volume) {
-    const args = ["volume", "create"];
-    if (volume.driver) {
-      args.push("--driver", volume.driver);
+    if (LINK_SYSCALLS.has(syscall)) {
+      const strings = quotedStrings(args);
+      if (strings.length) write(resolve4(dir, strings[strings.length - 1]));
+      continue;
     }
-    for (const [key, value] of Object.entries(volume.driverOptions ?? {})) {
-      args.push("--opt", `${key}=${value}`);
+    if (OPEN_SYSCALLS.has(syscall)) {
+      if (!CREATE_OR_TRUNC_FLAGS.test(openFlags(args))) continue;
+      const strings = quotedStrings(args);
+      if (strings.length) write(resolve4(dir, strings[0]));
+      continue;
     }
-    args.push(volume.name);
-    try {
-      await spawn3("docker", args);
-    } catch (error) {
-      const reason = this.getDockerErrorMessage(error);
-      if (this.isDockerUnavailableError(reason)) {
-        throw new DockerNotAvailableError();
-      }
-      throw new VolumeCreateError(volume.name, reason);
+    if (WRITE_SYSCALLS.has(syscall)) {
+      const p = fdPath(args);
+      if (p && Number(call.retval) > 0) write(posix.normalize(p));
+      continue;
     }
-  }
-  async cleanupCreatedVolumes() {
-    const volumes = [...this.createdVolumes].reverse();
-    for (const volume of volumes) {
-      try {
-        await spawn3("docker", ["volume", "rm", volume]);
-        this.createdVolumes.delete(volume);
-      } catch (error) {
-        const reason = this.getDockerErrorMessage(error);
-        if (this.isDockerUnavailableError(reason)) {
-          throw new DockerNotAvailableError();
-        }
-        throw new VolumeRemoveError(volume, reason);
-      }
+    if (TRUNCATE_SYSCALLS.has(syscall)) {
+      const p = fdPath(args) ?? quotedStrings(args)[0];
+      if (p) write(resolve4(dir, p));
     }
   }
-  async cleanupCreatedVolumesAfterFailure(originalError) {
-    try {
-      await this.cleanupCreatedVolumes();
-    } catch (cleanupError) {
-      if (originalError instanceof Error) {
-        const original = originalError;
-        original.suppressed = [...original.suppressed ?? [], cleanupError];
-      }
+  const keep = (path5) => {
+    if (traceFile && path5 === traceFile) return false;
+    if (traceDir && (path5 === traceDir || path5.startsWith(`${traceDir}/`))) {
+      return false;
     }
+    if (/^\/(proc|sys|dev)(\/|$)/.test(path5)) return false;
+    return matchesGlobs(path5, include, exclude);
+  };
+  const changes = [];
+  const emittedRenameTargets = /* @__PURE__ */ new Set();
+  for (const { from, to } of renames) {
+    if (!keep(to)) continue;
+    if (state.get(to) === "delete") continue;
+    changes.push({ op: "rename", path: to, from, timestamp: now });
+    emittedRenameTargets.add(to);
   }
-  getDockerErrorMessage(error) {
-    const err = error;
-    return err.stderr || err.stdout || err.message || String(error);
-  }
-  isDockerUnavailableError(message2) {
-    return message2.includes("Cannot connect") || message2.includes("docker daemon");
-  }
-  isMissingVolumeInspectError(message2) {
-    return message2.toLowerCase().includes("no such volume");
-  }
-  async startContainer(image, containerId) {
-    const args = this.buildDockerArgs(image, containerId);
-    try {
-      await spawn3("docker", args);
-    } catch (error) {
-      const err = error;
-      if (err.message?.includes("Cannot connect") || err.message?.includes("docker daemon") || err.stderr?.includes("Cannot connect")) {
-        throw new DockerNotAvailableError();
-      }
-      throw new ContainerCreationError(
-        this.getDockerErrorMessage(err),
-        image,
-        err
-      );
-    }
+  const tail = [];
+  for (const [path5, op] of state) {
+    if (emittedRenameTargets.has(path5)) continue;
+    if (keep(path5)) tail.push({ op, path: path5, timestamp: now });
   }
-  async stopContainer(containerId) {
+  tail.sort((a, b) => {
+    if (a.path < b.path) return -1;
+    if (a.path > b.path) return 1;
+    return 0;
+  });
+  changes.push(...tail);
+  return changes;
+}
+
+// packages/context/src/lib/sandbox/strace/file-changes.ts
+var DEFAULT_TRACE_DIR = "/tmp/dat-trace";
+function stripStraceDiagnostics(stderr) {
+  if (!stderr.includes("strace: ")) return stderr;
+  return stderr.split("\n").filter((line) => !line.startsWith("strace: ")).join("\n");
+}
+function warnOnFileChangesError(error) {
+  console.warn(
+    "[withStraceFileChanges] onFileChanges threw on spawn; isolated",
+    error
+  );
+}
+async function withStraceFileChanges(sandbox, options) {
+  const { include, exclude, onFileChanges } = options;
+  const onError = options.onError ?? warnOnFileChangesError;
+  const traceDir = options.traceDir ?? DEFAULT_TRACE_DIR;
+  const innerExecute = sandbox.executeCommand.bind(sandbox);
+  const innerReadFile = sandbox.readFile.bind(sandbox);
+  const innerWriteFiles = sandbox.writeFiles.bind(sandbox);
+  const removeTrace = (traceFile) => void innerExecute(`rm -f ${shellQuote(traceFile)}`).catch(() => {
+  });
+  const readChanges = async (traceFile) => {
     try {
-      await spawn3("docker", ["stop", containerId]);
+      return parseStraceTrace(await innerReadFile(traceFile), {
+        include,
+        exclude,
+        traceFile,
+        traceDir
+      });
     } catch {
+      return [];
+    } finally {
+      removeTrace(traceFile);
     }
-  }
-  async exec(command, options) {
+  };
+  const collectSpawn = async (traceFile) => {
+    const changes = await readChanges(traceFile);
+    if (!changes.length || !onFileChanges) return;
     try {
-      const result = await spawn3(
-        "docker",
-        ["exec", this.context.containerId, "sh", "-c", command],
-        { signal: options?.signal }
-      );
-      return {
-        stdout: result.stdout,
-        stderr: result.stderr,
-        exitCode: 0
-      };
+      await onFileChanges(changes);
     } catch (error) {
-      const err = error;
-      return {
-        stdout: err.stdout || "",
-        stderr: err.stderr || err.message || "",
-        exitCode: err.exitCode ?? 1
+      onError(error);
+    }
+  };
+  const decorated = {
+    async executeCommand(command, execOptions) {
+      const traceFile = `${traceDir}/${randomUUID2()}.strace`;
+      const sentinel = `__dat_trace_${randomUUID2()}__`;
+      const wrapped = buildTracedCommand(
+        command,
+        traceFile,
+        traceDir,
+        sentinel
+      );
+      let raw;
+      try {
+        raw = await innerExecute(wrapped, execOptions);
+      } catch (error) {
+        removeTrace(traceFile);
+        throw error;
+      }
+      const { stdout, trace } = splitTracedOutput(raw.stdout, sentinel);
+      const result = {
+        ...raw,
+        stdout,
+        stderr: stripStraceDiagnostics(raw.stderr)
       };
+      if (execOptions?.signal?.aborted) return result;
+      const changes = trace ? parseStraceTrace(trace, { include, exclude, traceFile, traceDir }) : [];
+      if (changes.length) {
+        useBashMeta()?.setHidden({ fileChanges: changes });
+        await onFileChanges?.(changes);
+      }
+      return result;
+    },
+    readFile: innerReadFile,
+    // The writeFile tool mutates the filesystem outside strace's view, so
+    // observe it directly: synthesize a `write` change per file (under the
+    // observation root) and run it through onFileChanges. A throw propagates to
+    // the writeFile tool's execute (which rejects), the same gate as the bash
+    // path — except there's no CommandResult here, so throw a plain Error to
+    // reject; BashException.format() is meaningful only for bash commands.
+    writeFiles: async (files) => {
+      await innerWriteFiles(files);
+      const now = Date.now();
+      const changes = files.map((f) => posix2.normalize(f.path)).filter((path5) => matchesGlobs(path5, include, exclude)).map((path5) => ({ op: "write", path: path5, timestamp: now }));
+      if (changes.length) await onFileChanges?.(changes);
+    },
+    dispose: async () => {
+      await innerExecute(`rm -rf ${shellQuote(traceDir)}`).catch(() => {
+      });
+      await sandbox.dispose();
+    },
+    [Symbol.asyncDispose]() {
+      return this.dispose();
     }
-  }
-  spawnProcess(command, options) {
-    const child = childSpawn("docker", [
-      "exec",
-      ...buildDockerExecFlags(options),
-      this.context.containerId,
-      "sh",
-      "-c",
-      command
-    ]);
-    return toSandboxProcess(child, options?.signal);
-  }
-  createSandboxMethods() {
-    const { containerId } = this.context;
-    const sandbox = {
-      executeCommand: async (command, options) => this.exec(command, options),
-      spawn: (command, options) => this.spawnProcess(command, options),
-      readFile: async (path5) => {
-        const result = await sandbox.executeCommand(`base64 "${path5}"`);
-        if (result.exitCode !== 0) {
-          throw new Error(`Failed to read file "${path5}": ${result.stderr}`);
-        }
-        return Buffer.from(result.stdout, "base64").toString("utf-8");
-      },
-      writeFiles: async (files) => {
-        for (const file of files) {
-          const dir = file.path.substring(0, file.path.lastIndexOf("/"));
-          if (dir) {
-            await sandbox.executeCommand(`mkdir -p "${dir}"`);
-          }
-          const base64Content = Buffer.from(file.content).toString("base64");
-          const result = await sandbox.executeCommand(
-            `echo "${base64Content}" | base64 -d > "${file.path}"`
-          );
-          if (result.exitCode !== 0) {
-            throw new Error(
-              `Failed to write file "${file.path}": ${result.stderr}`
-            );
-          }
+  };
+  if (sandbox.spawn) {
+    const innerSpawn = sandbox.spawn.bind(sandbox);
+    decorated.spawn = (command, spawnOptions) => {
+      const traceFile = `${traceDir}/${randomUUID2()}.strace`;
+      const child = innerSpawn(
+        buildStraceCommand(command, traceFile, traceDir),
+        spawnOptions
+      );
+      const exit = (async () => {
+        try {
+          return await child.exit;
+        } finally {
+          await collectSpawn(traceFile).catch(() => {
+          });
         }
-      },
-      dispose: async () => {
-        await this.stopContainer(containerId);
-        await this.cleanupCreatedVolumes();
-      }
+      })();
+      return { stdout: child.stdout, stderr: child.stderr, exit };
     };
-    return sandbox;
-  }
-};
-function validateEnvKey2(key) {
-  if (key.length === 0 || key.includes("=")) {
-    throw new DockerSandboxError(`Invalid environment variable key: "${key}"`);
   }
+  return decorated;
 }
-function buildDockerExecFlags(options) {
-  const flags = [];
-  if (options?.cwd) {
-    flags.push("-w", options.cwd);
+
+// packages/context/src/lib/sandbox/gcs.ts
+function gcs(options) {
+  return {
+    type: "bind",
+    hostPath: options.hostPath,
+    containerPath: options.mountPath,
+    readOnly: options.readOnly ?? false
+  };
+}
+
+// packages/context/src/lib/sandbox/installers/bin.ts
+import { basename, posix as posix3 } from "node:path";
+var NOT_FOUND_EXIT = 11;
+var CHMOD_FAILED_EXIT = 12;
+var BinInstaller = class extends Installer {
+  kind;
+  binary;
+  options;
+  #name;
+  #target;
+  constructor(binary, options = {}) {
+    super();
+    this.binary = binary;
+    this.options = options;
+    this.#name = resolveName(binary, options);
+    this.#target = options.target ?? posix3.join("/usr/local/bin", this.#name);
+    this.kind = `bin:${this.#name}`;
   }
-  if (options?.env) {
-    for (const [key, value] of Object.entries(options.env)) {
-      validateEnvKey2(key);
-      flags.push("-e", `${key}=${value}`);
-    }
+  async install(ctx) {
+    const b = shellQuote(this.binary);
+    const t = shellQuote(this.#target);
+    const dir = shellQuote(posix3.dirname(this.#target));
+    const result = await ctx.exec(
+      `test -f ${b} || { echo "binary not found at ${this.binary}" >&2; exit ${NOT_FOUND_EXIT}; }; if ! test -x ${b}; then chmod +x ${b} || exit ${CHMOD_FAILED_EXIT}; fi; mkdir -p ${dir} && ln -sf ${b} ${t}`
+    );
+    if (result.exitCode === 0) return;
+    throw new InstallError({
+      target: this.#name,
+      source: "bin",
+      reason: explainFailure(result.exitCode, result.stderr, this.binary),
+      containerId: ctx.containerId
+    });
   }
-  return flags;
+};
+function bin(binary, options) {
+  return new BinInstaller(binary, options);
 }
-function toSandboxProcess(child, abortSignal) {
-  if (!child.stdout || !child.stderr) {
-    child.kill("SIGKILL");
-    throw new DockerSandboxError("docker exec child missing stdio streams");
+function explainFailure(exitCode, stderr, binary) {
+  if (exitCode === NOT_FOUND_EXIT) {
+    return `binary not found at ${binary}`;
   }
-  const onAbort = abortSignal ? () => child.kill("SIGKILL") : void 0;
-  if (abortSignal && onAbort) {
-    if (abortSignal.aborted) onAbort();
-    else abortSignal.addEventListener("abort", onAbort, { once: true });
+  if (exitCode === CHMOD_FAILED_EXIT && /read-only file system/i.test(stderr)) {
+    return `${binary} is not executable and the bind mount is read-only \u2014 run \`chmod +x\` on the host, or mount with \`readOnly: false\`. (${stderr.trim()})`;
   }
-  return {
-    stdout: Readable2.toWeb(child.stdout),
-    stderr: Readable2.toWeb(child.stderr),
-    exit: new Promise((resolve4, reject) => {
-      const settle = () => {
-        child.removeListener("exit", onExitEvent);
-        child.removeListener("error", onError);
-        if (abortSignal && onAbort) {
-          abortSignal.removeEventListener("abort", onAbort);
-        }
-      };
-      const onError = (err) => {
-        settle();
-        reject(err);
-      };
-      const onExitEvent = (code, exitSignal) => {
-        settle();
-        resolve4({ code, signal: exitSignal, success: code === 0 });
-      };
-      child.on("exit", onExitEvent);
-      child.on("error", onError);
-    })
-  };
+  return stderr || `bin installer failed with exit code ${exitCode}`;
 }
-var RuntimeStrategy = class extends DockerSandboxStrategy {
-  image;
-  installers;
-  constructor(args = {}) {
-    super({
-      volumes: args.volumes,
-      resources: args.resources,
-      env: args.env,
-      name: args.name,
-      command: args.command
-    });
-    this.image = args.image ?? "alpine:latest";
-    this.installers = args.installers ?? [];
-  }
-  async getImage() {
-    return this.image;
+function resolveName(binary, options) {
+  if (options.name) return options.name;
+  const base = basename(binary);
+  const dot = base.lastIndexOf(".");
+  return dot > 0 ? base.slice(0, dot) : base;
+}
+
+// packages/context/src/lib/sandbox/installers/url-binary.ts
+var UrlBinaryInstaller = class extends Installer {
+  kind;
+  options;
+  constructor(options) {
+    super();
+    this.options = options;
+    this.kind = `url-binary:${options.name}`;
   }
-  async configure() {
-    const ctx = createInstallerContext(this.context.containerId, this.image);
-    for (const installer of this.installers) {
-      await installer.install(ctx);
-    }
+  async install(ctx) {
+    const url = await resolveUrl(ctx, this.options);
+    await downloadAndInstall(
+      ctx,
+      this.options.name,
+      url,
+      this.options.binaryPath
+    );
   }
 };
-var DockerfileStrategy = class extends DockerSandboxStrategy {
-  imageTag;
-  dockerfile;
-  dockerContext;
-  showBuildLogs;
-  constructor(args) {
-    super({
-      volumes: args.volumes,
-      resources: args.resources,
-      env: args.env,
-      name: args.name,
-      command: args.command
+function urlBinary(options) {
+  return new UrlBinaryInstaller(options);
+}
+async function resolveUrl(ctx, options) {
+  if (typeof options.url === "string") return options.url;
+  const arch = await ctx.arch();
+  const archUrl = options.url[arch];
+  if (!archUrl) {
+    throw new InstallError({
+      target: options.name,
+      source: "url",
+      reason: `No URL provided for architecture "${arch}". Available: ${Object.keys(options.url).join(", ")}`,
+      containerId: ctx.containerId
     });
-    this.dockerfile = args.dockerfile;
-    this.dockerContext = args.context ?? ".";
-    this.showBuildLogs = args.showBuildLogs ?? false;
-    this.imageTag = this.computeImageTag();
-  }
-  computeImageTag() {
-    const content = this.isInlineDockerfile() ? this.dockerfile : readFileSync2(this.dockerfile, "utf-8");
-    const hash = createHash("sha256").update(content).digest("hex").slice(0, 12);
-    return `sandbox-${hash}`;
-  }
-  isInlineDockerfile() {
-    return this.dockerfile.includes("\n");
-  }
-  async getImage() {
-    const exists = await this.imageExists();
-    if (!exists) {
-      await this.buildImage();
-    }
-    return this.imageTag;
   }
-  async configure() {
-  }
-  async imageExists() {
-    try {
-      await spawn3("docker", ["image", "inspect", this.imageTag]);
-      return true;
-    } catch {
-      return false;
-    }
+  return archUrl;
+}
+async function downloadAndInstall(ctx, name, url, binaryPath, source = "url") {
+  await ctx.ensureTool("curl");
+  const isTarGz = url.endsWith(".tar.gz") || url.endsWith(".tgz");
+  const installCmd = isTarGz ? buildTarGzInstallCmd(name, url, binaryPath ?? name) : buildRawInstallCmd(name, url);
+  const result = await ctx.exec(installCmd);
+  if (result.exitCode !== 0) {
+    throw new InstallError({
+      target: name,
+      source,
+      url,
+      reason: result.stderr,
+      containerId: ctx.containerId
+    });
   }
-  async buildImage() {
-    try {
-      if (this.isInlineDockerfile()) {
-        const buildCmd = `echo '${this.dockerfile.replace(/'/g, "'\\''")}' | docker build -t ${this.imageTag} -f - ${this.dockerContext}`;
-        if (this.showBuildLogs) {
-          await this.runStreamed("sh", ["-c", buildCmd]);
-        } else {
-          await spawn3("sh", ["-c", buildCmd]);
-        }
-      } else {
-        const args = [
-          "build",
-          "-t",
-          this.imageTag,
-          "-f",
-          this.dockerfile,
-          this.dockerContext
-        ];
-        if (this.showBuildLogs) {
-          await this.runStreamed("docker", args);
-        } else {
-          await spawn3("docker", args);
-        }
-      }
-    } catch (error) {
-      const err = error;
-      throw new DockerfileBuildError(err.stderr || err.message);
-    }
+}
+function buildTarGzInstallCmd(name, url, binaryPathInArchive) {
+  return `
+    set -e
+    NAME=${shellQuote(name)}
+    URL=${shellQuote(url)}
+    BIN_IN_ARCHIVE=${shellQuote(binaryPathInArchive)}
+    TMPDIR=$(mktemp -d)
+    cd "$TMPDIR"
+    curl -fsSL "$URL" -o archive.tar.gz
+    tar -xzf archive.tar.gz
+    BINARY_FILE=$(find . -name "$BIN_IN_ARCHIVE" -o -name "$NAME" | head -1)
+    if [ -z "$BINARY_FILE" ]; then
+      echo "Binary not found in archive. Contents:" >&2
+      find . -type f >&2
+      exit 1
+    fi
+    chmod +x "$BINARY_FILE"
+    mv "$BINARY_FILE" "/usr/local/bin/$NAME"
+    cd /
+    rm -rf "$TMPDIR"
+  `;
+}
+function buildRawInstallCmd(name, url) {
+  return `
+    NAME=${shellQuote(name)}
+    URL=${shellQuote(url)}
+    curl -fsSL "$URL" -o "/usr/local/bin/$NAME"
+    chmod +x "/usr/local/bin/$NAME"
+  `;
+}
+
+// packages/context/src/lib/sandbox/installers/github-release.ts
+var GithubReleaseInstaller = class extends Installer {
+  kind;
+  options;
+  constructor(options) {
+    super();
+    this.options = options;
+    this.kind = `github-release:${options.owner}/${options.repo}@${options.version}`;
   }
-  /**
-   * Run a build command with stdio inherited so its output streams live to the
-   * parent terminal. On failure the build error is already on screen; the
-   * rejection just carries the exit code.
-   */
-  runStreamed(command, args) {
-    return new Promise((resolve4, reject) => {
-      const child = childSpawn(command, args, { stdio: "inherit" });
-      child.once("error", reject);
-      child.once(
-        "exit",
-        (code) => code === 0 ? resolve4() : reject(
-          new Error(
-            `docker build exited with code ${code} (see build output above)`
-          )
-        )
-      );
-    });
+  async install(ctx) {
+    const arch = await ctx.arch();
+    const assetName = this.options.asset(arch);
+    const url = `https://github.com/${this.options.owner}/${this.options.repo}/releases/download/${this.options.version}/${assetName}`;
+    await downloadAndInstall(
+      ctx,
+      this.options.name,
+      url,
+      this.options.binaryPath,
+      "github-release"
+    );
   }
 };
-var ComposeStrategy = class extends DockerSandboxStrategy {
-  projectName;
-  composeFile;
-  service;
-  constructor(args) {
-    super({ resources: args.resources });
-    this.composeFile = args.compose;
-    this.service = args.service;
-    this.projectName = this.computeProjectName();
-  }
-  computeProjectName() {
-    const content = readFileSync2(this.composeFile, "utf-8");
-    const hash = createHash("sha256").update(content).digest("hex").slice(0, 8);
-    return `sandbox-${hash}`;
-  }
-  async getImage() {
-    return "";
+function githubRelease(options) {
+  return new GithubReleaseInstaller(options);
+}
+
+// packages/context/src/lib/sandbox/installers/npm.ts
+var NODE_BINARIES = ["node", "npm"];
+var ENSURE_RUNTIME_HINT = "Pass `{ ensureRuntime: true }` to auto-install, or add it via `pkg([...])`.";
+var NpmInstaller = class extends Installer {
+  kind;
+  packageName;
+  options;
+  constructor(packageName, options = {}) {
+    super();
+    this.packageName = packageName;
+    this.options = options;
+    this.kind = `npm:${packageName}`;
   }
-  async startContainer(_image, _containerId) {
-    try {
-      await spawn3("docker", [
-        "compose",
-        "-f",
-        this.composeFile,
-        "-p",
-        this.projectName,
-        "up",
-        "-d"
-      ]);
-    } catch (error) {
-      const err = error;
-      if (err.stderr?.includes("Cannot connect")) {
-        throw new DockerNotAvailableError();
-      }
-      throw new ComposeStartError(this.composeFile, err.stderr || err.message);
+  async install(ctx) {
+    await ensureNodeRuntime(ctx, this.options.ensureRuntime ?? false);
+    const spec = this.options.version ? `${this.packageName}@${this.options.version}` : this.packageName;
+    const result = await ctx.exec(`npm install -g ${spec}`);
+    if (result.exitCode !== 0) {
+      throw new InstallError({
+        target: this.packageName,
+        source: "npm",
+        reason: result.stderr,
+        containerId: ctx.containerId
+      });
     }
   }
-  defaultContainerId() {
-    return this.projectName;
+};
+function npm(packageName, options) {
+  return new NpmInstaller(packageName, options);
+}
+async function ensureNodeRuntime(ctx, ensure) {
+  if (ensure) {
+    await ctx.ensureTool("node", "nodejs");
+    await ctx.ensureTool("npm");
+    return;
   }
-  async configure() {
+  const check = await ctx.exec("which node && which npm");
+  if (check.exitCode !== 0) {
+    throw new MissingRuntimeError(
+      "npm",
+      NODE_BINARIES,
+      ENSURE_RUNTIME_HINT,
+      ctx.containerId
+    );
   }
-  async exec(command, options) {
-    try {
-      const result = await spawn3(
-        "docker",
-        [
-          "compose",
-          "-f",
-          this.composeFile,
-          "-p",
-          this.projectName,
-          "exec",
-          "-T",
-          this.service,
-          "sh",
-          "-c",
-          command
-        ],
-        { signal: options?.signal }
-      );
-      return { stdout: result.stdout, stderr: result.stderr, exitCode: 0 };
-    } catch (error) {
-      const err = error;
-      return {
-        stdout: err.stdout || "",
-        stderr: err.stderr || err.message || "",
-        exitCode: err.exitCode ?? 1
-      };
-    }
+}
+
+// packages/context/src/lib/sandbox/installers/package-manager.ts
+var PackageInstaller = class extends Installer {
+  kind;
+  packages;
+  constructor(packages) {
+    super();
+    this.packages = packages;
+    this.kind = packages.length === 0 ? "pkg:<empty>" : `pkg:${packages.join(",")}`;
   }
-  spawnProcess(command, options) {
-    const child = childSpawn("docker", [
-      "compose",
-      "-f",
-      this.composeFile,
-      "-p",
-      this.projectName,
-      "exec",
-      "-T",
-      ...buildDockerExecFlags(options),
-      this.service,
-      "sh",
-      "-c",
-      command
-    ]);
-    return toSandboxProcess(child, options?.signal);
+  async install(ctx) {
+    if (this.packages.length === 0) return;
+    await ctx.installPackages([...this.packages]);
   }
-  async stopContainer(_containerId) {
-    try {
-      await spawn3("docker", [
-        "compose",
-        "-f",
-        this.composeFile,
-        "-p",
-        this.projectName,
-        "down"
-      ]);
-    } catch {
+};
+function pkg(packages) {
+  return new PackageInstaller(packages);
+}
+
+// packages/context/src/lib/sandbox/installers/pip.ts
+var PYTHON_BINARIES = ["python3", "pip3"];
+var PipInstaller = class extends Installer {
+  kind;
+  packageName;
+  options;
+  constructor(packageName, options = {}) {
+    super();
+    this.packageName = packageName;
+    this.options = options;
+    this.kind = `pip:${packageName}`;
+  }
+  async install(ctx) {
+    await ensurePythonRuntime(ctx, this.options.ensureRuntime ?? false);
+    const spec = this.options.version ? `${this.packageName}${formatVersion(this.options.version)}` : this.packageName;
+    const flags = this.options.breakSystemPackages ?? true ? "--break-system-packages" : "";
+    const result = await ctx.exec(`pip3 install ${flags} ${spec}`.trim());
+    if (result.exitCode !== 0) {
+      throw new InstallError({
+        target: this.packageName,
+        source: "pypi",
+        reason: result.stderr,
+        containerId: ctx.containerId
+      });
     }
   }
 };
-async function createDockerSandbox(options = {}) {
-  let strategy;
-  if (isComposeOptions(options)) {
-    strategy = new ComposeStrategy({
-      compose: options.compose,
-      service: options.service,
-      resources: options.resources
-    });
-  } else if (isDockerfileOptions(options)) {
-    strategy = new DockerfileStrategy({
-      dockerfile: options.dockerfile,
-      context: options.context,
-      showBuildLogs: options.showBuildLogs,
-      volumes: options.volumes,
-      resources: options.resources,
-      env: options.env,
-      name: options.name,
-      command: options.command
-    });
-  } else {
-    strategy = new RuntimeStrategy({
-      image: options.image,
-      installers: options.installers,
-      volumes: options.volumes,
-      resources: options.resources,
-      env: options.env,
-      name: options.name,
-      command: options.command
-    });
-  }
-  return strategy.create();
+function pip(packageName, options) {
+  return new PipInstaller(packageName, options);
 }
-async function useSandbox(options, fn) {
-  const sandbox = await createDockerSandbox(options);
-  try {
-    return await fn(sandbox);
-  } finally {
-    await sandbox.dispose();
+async function ensurePythonRuntime(ctx, ensure) {
+  if (ensure) {
+    const pipPackage = ctx.packageManager === "apk" ? "py3-pip" : "python3-pip";
+    await ctx.ensureTool("python3");
+    await ctx.ensureTool("pip3", pipPackage);
+    return;
+  }
+  const check = await ctx.exec("which python3 && which pip3");
+  if (check.exitCode !== 0) {
+    throw new MissingRuntimeError(
+      "pip",
+      PYTHON_BINARIES,
+      "Pass `{ ensureRuntime: true }` to auto-install, or add via `pkg([...])` (Alpine: `python3 py3-pip`; Debian: `python3 python3-pip`).",
+      ctx.containerId
+    );
   }
 }
-
-// packages/context/src/lib/sandbox/gcs.ts
-function gcs(options) {
-  return {
-    type: "bind",
-    hostPath: options.hostPath,
-    containerPath: options.mountPath,
-    readOnly: options.readOnly ?? false
-  };
+function formatVersion(version) {
+  return /^[<>=!~]/.test(version) ? version : `==${version}`;
 }
 
 // packages/context/src/lib/sandbox/subcommand.ts
@@ -8832,6 +9338,9 @@ async function createVirtualSandbox(options) {
       }
     },
     async dispose() {
+    },
+    [Symbol.asyncDispose]() {
+      return this.dispose();
     }
   };
 }
@@ -8896,11 +9405,14 @@ ${lines.join("\n")}`;
 }
 function skillsReminder(skillsOrClassifier, options) {
   const classifier = Array.isArray(skillsOrClassifier) ? new BM25Classifier(skillsOrClassifier) : skillsOrClassifier;
-  return reminder((ctx) => {
-    const matches = classifier.match(ctx.content, options);
-    if (matches.length === 0) return "";
-    return formatSkillReminder(matches);
-  });
+  return reminder(
+    (ctx) => {
+      const matches = classifier.match(ctx.content, options);
+      if (matches.length === 0) return "";
+      return formatSkillReminder(matches);
+    },
+    { target: "user" }
+  );
 }
 
 // packages/context/src/lib/soul/protocol.md
@@ -12030,6 +12542,13 @@ export {
   AgentOsCreationError,
   AgentOsNotAvailableError,
   AgentOsSandboxError,
+  AppleContainerCreationError,
+  AppleContainerImageBuildError,
+  AppleContainerSandboxError,
+  AppleContainerVolumeCreateError,
+  AppleContainerVolumeInspectError,
+  AppleContainerVolumePathError,
+  AppleContainerVolumeRemoveError,
   AsyncResolver,
   BM25Classifier,
   BashException,
@@ -12037,6 +12556,10 @@ export {
   ComposeStartError,
   ComposeStrategy,
   ContainerCreationError,
+  ContainerSandboxError,
+  ContainerSandboxStrategy,
+  ContainerServiceNotRunningError,
+  ContainerfileStrategy,
   ContextEngine,
   ContextRenderer,
   ContextStore,
@@ -12048,9 +12571,7 @@ export {
   DaytonaSandboxError,
   DockerNotAvailableError,
   DockerSandboxError,
-  DockerSandboxStrategy,
   DockerfileBuildError,
-  DockerfileStrategy,
   FragmentLoaderResolver,
   FunctionResolver,
   GeneratorResolver,
@@ -12076,7 +12597,6 @@ export {
   SqlServerContextStore,
   SqliteContextStore,
   SqliteStreamStore,
-  StraceUnavailableError,
   StreamManager,
   StreamStore,
   TitleGenerator,
@@ -12102,6 +12622,7 @@ export {
   applyPartReminder,
   applyReminderToMessage,
   applyRemindersToToolOutput,
+  applyUserRemindersToMessage,
   asStaticWordPartText,
   asStaticWordText,
   assertCountSpec,
@@ -12120,6 +12641,7 @@ export {
   correction,
   createAdaptivePollingState,
   createAgentOsSandbox,
+  createAppleContainerSandbox,
   createBashTool,
   createBinaryBridges,
   createDaytonaSandbox,
@@ -12135,6 +12657,8 @@ export {
   defineSubcommandGroup,
   discoverSkillMappings,
   discoverSkillsInDirectory,
+  dockerEngine,
+  downloadAndInstall,
   elapsedExceeds,
   encodeSerializedValue,
   errorRecoveryGuardrail,
@@ -12153,6 +12677,7 @@ export {
   getFragmentData,
   getLocaleFromMessage,
   getModelsRegistry,
+  getReminderOnceIds,
   getReminderRanges,
   getSeason,
   githubRelease,
@@ -12161,6 +12686,7 @@ export {
   hint,
   hourChanged,
   identity,
+  isAppleContainerfileOptions,
   isComposeOptions,
   isConditionalReminder,
   isDebianBased,
@@ -12188,7 +12714,6 @@ export {
   once,
   or,
   parseFrontmatter,
-  parseStraceTrace,
   pass,
   persistedWriter,
   persona,
@@ -12206,7 +12731,6 @@ export {
   resetAdaptivePolling,
   resolveReminder,
   resolveReminderAsync,
-  resolveReminderText,
   resolveTz,
   role,
   runGuardrailChain,
@@ -12215,7 +12739,6 @@ export {
   seasonChanged,
   seasonReminder,
   selfCritique,
-  selfTestStrace,
   shellQuote,
   skills,
   skillsReminder,
@@ -12233,21 +12756,23 @@ export {
   timeReminder,
   toFragment,
   toMessageFragment,
+  toToolReminderModelOutput,
   toolCall,
   toolCallCount,
   toolCalled,
   toolFailed,
-  traceFileChanges,
   uploadSkills,
   urlBinary,
   usageExceeds,
   useAgentOsSandbox,
+  useAppleContainerSandbox,
   useBashMeta,
   useSandbox,
   user,
   visualizeGraph,
   weekChanged,
   withAbortSignal,
+  withStraceFileChanges,
   withinLastN,
   workflow,
   yearChanged,