maka-agent 0.2.0-dev.62.20260928 → 0.2.0-dev.67.20261002

package/node_modules/{@maka/runtime/node_modules/ai → ai}/docs/03-ai-sdk-harnesses/02-harness-agent.mdx

@@ -11,7 +11,7 @@ results while a preconfigured harness powers these results.
 
 ## Installation
 
-Install the core harness package, a harness adapter, and a sandbox provider:
+Install the core harness package, a harness adapter, and a sandbox adapter:
 
 <InstallPackages packages="@ai-sdk/harness @ai-sdk/harness-claude-code @ai-sdk/sandbox-vercel" />
 
@@ -24,15 +24,10 @@ like `@ai-sdk/sandbox-vercel`. Host-runtime harnesses such as Pi can also run wi
 ```ts
 import { HarnessAgent } from '@ai-sdk/harness/agent';
 import { claudeCode } from '@ai-sdk/harness-claude-code';
-import { createVercelSandbox } from '@ai-sdk/sandbox-vercel';
 
 export const agent = new HarnessAgent({
   harness: claudeCode,
   model: 'claude-sonnet-4-6',
-  sandbox: createVercelSandbox({
-    runtime: 'node24',
-    ports: [4000],
-  }),
   instructions:
     'You are a careful coding assistant. Prefer small changes and explain tradeoffs.',
 });
@@ -40,6 +35,17 @@ export const agent = new HarnessAgent({
 
 Construct the agent at module scope. It holds configuration, not a live session.
 Live state belongs to `HarnessAgentSession`.
+Create a sandbox session separately and pass it to `agent.createSession()`:
+
+```ts
+import { createVercelNetworkSandboxSession } from '@ai-sdk/sandbox-vercel';
+
+const sandboxSession = await createVercelNetworkSandboxSession({
+  runtime: 'node24',
+  ports: [4000],
+  template: await agent.getSandboxTemplate(),
+});
+```
 
 Set `model` to select the model that the harness runtime uses. Model identifiers
 are specific to each harness. When omitted, the harness uses its default model.
@@ -51,7 +57,7 @@ are set.
 ## Run a Turn
 
 ```ts
-const session = await agent.createSession();
+const session = await agent.createSession({ sandboxSession });
 
 let exitCode = 0;
 try {
@@ -66,6 +72,7 @@ try {
   console.error(err);
 } finally {
   await session.destroy();
+  await sandboxSession.destroy();
   process.exit(exitCode);
 }
 ```
@@ -75,7 +82,7 @@ try {
 Use `stream()` for incremental output:
 
 ```ts
-const session = await agent.createSession();
+const session = await agent.createSession({ sandboxSession });
 
 let exitCode = 0;
 try {
@@ -94,6 +101,7 @@ try {
   console.error(err);
 } finally {
   await session.destroy();
+  await sandboxSession.destroy();
   process.exit(exitCode);
 }
 ```
@@ -106,7 +114,6 @@ steps, and tool executions:
 ```ts
 const agent = new HarnessAgent({
   harness: claudeCode,
-  sandbox,
   tools: { weather },
   onStart: event => console.log('call started', event.callId),
   onStepStart: event => console.log('step started', event.stepNumber),
@@ -131,6 +138,39 @@ Harness runtimes execute their built-in tools internally. For those tools,
 lifecycle after the runtime reports the result. The callbacks are still
 delivered before the tool result is published to the result stream.
 
+## Runtime Context
+
+Set `runtimeContext` on `HarnessAgent` to make application context available to
+every turn. Use `prepareCall` to replace it for each new prompt turn. The
+prepared context is available through `generate()` and `stream()` and remains
+the same during in-memory continuations with `continueGenerate()` and
+`continueStream()`. Lifecycle callbacks receive the full context, and it is
+also available on each result's `finalStep.runtimeContext`.
+
+```ts
+const agent = new HarnessAgent({
+  harness: claudeCode,
+  runtimeContext: {
+    conversationId: 'conversation-123',
+    userId: 'user-456',
+  },
+  telemetry: {
+    includeRuntimeContext: {
+      conversationId: true,
+    },
+  },
+  onEnd: ({ runtimeContext }) => {
+    console.log(runtimeContext.userId);
+  },
+});
+```
+
+Runtime context is excluded from telemetry by default. Use
+`telemetry.includeRuntimeContext` to allowlist individual top-level properties;
+only properties set to `true` are sent to telemetry integrations. Lifecycle
+callbacks and results still receive the full context, so avoid storing secrets
+that those consumers should not access.
+
 ## Generate Structured Output
 
 Set `output` when constructing `HarnessAgent` to require the same typed output
@@ -145,7 +185,6 @@ import { z } from 'zod';
 
 const agent = new HarnessAgent({
   harness: claudeCode,
-  sandbox,
   output: Output.object({
     schema: z.object({
       recipe: z.object({
@@ -163,7 +202,7 @@ const agent = new HarnessAgent({
   }),
 });
 
-const session = await agent.createSession();
+const session = await agent.createSession({ sandboxSession });
 try {
   const result = await agent.generate({
     session,
@@ -205,10 +244,10 @@ of relying on message replay.
 End every session explicitly:
 
 - `session.destroy()` stops the runtime and discards resumability.
-- `session.detach()` parks the runtime and sandbox, returns resume state, and
-  keeps the sandbox warm for a later attach. If the turn is unfinished, the
+- `session.detach()` parks the runtime, returns resume state, and leaves a
+  supplied sandbox running for a later attach. If the turn is unfinished, the
   resume state includes the continuation state.
-- `session.stop()` saves resume state, then stops the runtime and sandbox. If
+- `session.stop()` saves resume state, then stops the runtime. If
   the turn is unfinished, the resume state includes the continuation state.
 - `session.suspendTurn()` is for advanced active-turn continuation across a
   process boundary.
@@ -221,7 +260,7 @@ HTTP routes that need multi-turn continuity.
 ## Change Settings Between Turns
 
 Use `callOptionsSchema` and `prepareCall` to derive `model`, `skills`,
-`instructions`, and `tools` for each new turn. This follows the same
+`instructions`, `tools`, and `runtimeContext` for each new turn. This follows the same
 call-options pattern as `ToolLoopAgent`:
 
 ```ts
@@ -237,7 +276,6 @@ const getPolicy = tool({
 
 const agent = new HarnessAgent({
   harness: claudeCode,
-  sandbox,
   tools: { getPolicy },
   callOptionsSchema: z.object({
     area: z.enum(['frontend', 'backend']),
@@ -248,12 +286,13 @@ const agent = new HarnessAgent({
     ...call,
     model: options.useCheaperModel ? 'claude-haiku-4-5' : undefined,
     instructions: `Work as the ${options.area} specialist.`,
+    runtimeContext: { area: options.area },
     skills: [options.area === 'frontend' ? frontendSkill : backendSkill],
     tools: options.enablePolicyTool ? { getPolicy } : undefined,
   }),
 });
 
-const session = await agent.createSession();
+const session = await agent.createSession({ sandboxSession });
 try {
   await agent.generate({
     session,
@@ -305,7 +344,10 @@ the harness runtime but do not stop or destroy the supplied sandbox session.
 In this case, the agent does not need a `sandbox` provider in its constructor.
 
 ```ts
-const session = await agent.createSession({ sessionId: chatId });
+const session = await agent.createSession({
+  sessionId: chatId,
+  sandboxSession,
+});
 
 try {
   const result = await agent.stream({ session, messages });
@@ -326,22 +368,39 @@ try {
 
 ## Resuming
 
-Persist the opaque resume state and pass it back with the original `sessionId`:
+Persist the opaque resume state. In this example, the harness `sessionId` is
+`chatId`, and the sandbox ID is derived from the same known ID. If your
+application cannot derive the sandbox ID, persist `sandboxSession.id` alongside
+the harness `sessionId` and resume state instead. Reattach the sandbox before
+asking the agent to resume. When you choose `sandboxId` on creation, it names a **new**
+live sandbox and never looks one up. Reusing that ID with the creator fails
+if the named sandbox exists; only the resume function performs a lookup.
 
 ```ts
 const resumeState = await loadResumeState({ chatId });
+const sandboxId = `chat-${chatId}`;
+
+const sandboxSession = resumeState
+  ? await resumeVercelNetworkSandboxSession({ sandboxId })
+  : await createVercelNetworkSandboxSession({
+      sandboxId,
+      ports: [4000],
+      template: await agent.getSandboxTemplate(),
+    });
 
 const session = await agent.createSession(
   resumeState
-    ? { sessionId: chatId, resumeFrom: resumeState }
-    : { sessionId: chatId },
+    ? { sessionId: chatId, resumeFrom: resumeState, sandboxSession }
+    : { sessionId: chatId, sandboxSession },
 );
 ```
 
 `HarnessAgent` validates that the resume state was produced by the same harness
 adapter before handing it to the runtime. If the resume state includes an
 unfinished turn, call `continueStream()` or `continueGenerate()` before sending a
-new prompt.
+new prompt. The Vercel resume function reattaches whether the sandbox is still
+running after `detach()` or stopped with a restorable snapshot. After
+`sandboxSession.destroy()` deletes it, that ID cannot be resumed.
 
 ## Continue a Suspended Turn
 
@@ -362,6 +421,10 @@ When you only have raw continuation state from `suspendTurn()`, resume with
 const session = await agent.createSession({
   sessionId: chatId,
   continueFrom: continuationState,
+  sandboxSession,
+  // Rebind this when the suspended turn used host-only tool context:
+  toolsContext,
+  runtimeContext,
 });
 
 const result = await agent.continueStream({ session });
@@ -370,6 +433,13 @@ const result = await agent.continueStream({ session });
 Use `continueStream()` for incremental output, or `continueGenerate()` to drain
 the continued turn and return a `GenerateTextResult`.
 
+`toolsContext` and `runtimeContext` are intentionally not stored in
+continuation state because they can contain credentials or non-serializable
+host objects. When a suspended turn used context derived by `prepareCall`,
+pass the same values to `createSession` to rebind them in the process that
+continues the turn. After a process resume without rebinding, the continuation
+uses the agent's constructor-level `runtimeContext` and `toolsContext`.
+
 ## Stop After a Harness Step
 
 Use `stopWhen` to opt into semantic step boundaries. Predicates run after real
@@ -384,14 +454,10 @@ import { isStepCount } from 'ai';
 
 const steppedAgent = new HarnessAgent({
   harness: claudeCode,
-  sandbox: createVercelSandbox({
-    runtime: 'node24',
-    ports: [4000],
-  }),
   stopWhen: isStepCount(1),
 });
 
-const session = await steppedAgent.createSession();
+const session = await steppedAgent.createSession({ sandboxSession });
 const result = await steppedAgent.generate({
   session,
   prompt: 'Create a short TODO.md for this repository.',
@@ -427,10 +493,6 @@ files or lightweight configuration.
 ```ts
 const agent = new HarnessAgent({
   harness: claudeCode,
-  sandbox: createVercelSandbox({
-    runtime: 'node24',
-    ports: [4000],
-  }),
   sandboxConfig: {
     workDir: 'repo',
     bootstrapHash: 'ripgrep-v1',
@@ -456,82 +518,62 @@ const agent = new HarnessAgent({
 ```
 
 `workDir` is optional. When provided, it must be relative to the sandbox's
-default working directory and is used as the session working directory. When
-omitted, regular sessions use the default `<harnessId>-<sessionId>` directory,
-while `onBootstrap` receives the sandbox's default working directory.
+default working directory and is used as the session working directory. Set it
+to `'.'` to use the sandbox's default working directory itself. When omitted,
+regular sessions use the default `<harnessId>-<sessionId>` directory, while
+`onBootstrap` receives the sandbox's default working directory.
 
 ## Prepare Reusable Sandboxes
 
-Use `prepareHarnessSandboxTemplate()` when you want the sandbox provider to
-create or refresh its reusable template for one harness ahead of time:
+Use `agent.getSandboxTemplate()` to resolve one harness's bootstrap recipe and
+`sandboxConfig.onBootstrap` before creating a sandbox. The template's identity
+is known before sandbox creation. Vercel persists the prepared snapshot and
+creates a live sandbox from it; identical calls reuse that snapshot:
 
 ```ts
-import { prepareHarnessSandboxTemplate } from '@ai-sdk/harness/agent';
-
-await prepareHarnessSandboxTemplate({
-  harness: claudeCode,
-  sandboxProvider: createVercelSandbox({
-    runtime: 'node24',
-    ports: [4000],
-  }),
-  sandboxConfig: {
-    bootstrapHash: 'ripgrep-v1',
-    onBootstrap: async ({ session, abortSignal }) => {
-      await session.run({
-        command:
-          'command -v rg >/dev/null || (apt-get update && apt-get install -y ripgrep)',
-        abortSignal,
-      });
-    },
-  },
+const sandboxSession = await createVercelNetworkSandboxSession({
+  runtime: 'node24',
+  ports: [4000],
+  template: await agent.getSandboxTemplate(),
 });
+
+const session = await agent.createSession({ sandboxSession });
+try {
+  await agent.generate({ session, prompt: 'Inspect this repository.' });
+} finally {
+  await session.destroy();
+  await sandboxSession.destroy();
+}
 ```
 
-Use `prepareSandboxForHarness()` when you own the native sandbox lifecycle and
-want to snapshot the prepared sandbox yourself. It applies the selected harness
-bootstrap recipes and `sandboxConfig.onBootstrap`, then returns preparation
-metadata. It does not stop or snapshot the sandbox.
+For multiple harnesses sharing a caller bootstrap hook, build one template from
+all adapters. The last adapter wins for duplicate `harnessId` values, and the
+recipe identities are sorted before hashing. `onSession` is not part of the
+template and runs separately on every acquired session.
 
 ```ts
-import { HarnessAgent, prepareSandboxForHarness } from '@ai-sdk/harness/agent';
-import { createVercelSandbox } from '@ai-sdk/sandbox-vercel';
-import { Sandbox } from '@vercel/sandbox';
-
-const nativeSandbox = await Sandbox.create({
-  runtime: 'node24',
-  ports: [4000],
-});
-const sandboxProvider = createVercelSandbox({ sandbox: nativeSandbox });
-const session = await sandboxProvider.createSession();
+import { createHarnessSandboxTemplate } from '@ai-sdk/harness/agent';
 
-const preparation = await prepareSandboxForHarness({
-  session: session.restricted(),
+const template = await createHarnessSandboxTemplate({
   harnesses: [claudeCode, codex],
   sandboxConfig,
 });
+console.log(template?.identity);
 
-const { snapshot } = await nativeSandbox.stop();
-if (snapshot == null) {
-  throw new Error('Prepared sandbox did not create a snapshot.');
-}
-
-const sandboxFromSnapshot = await Sandbox.create({
-  source: {
-    type: 'snapshot',
-    snapshotId: snapshot.id,
-  },
+const sandboxSession = await createVercelNetworkSandboxSession({
+  source: { type: 'snapshot', snapshotId: baseSnapshotId },
   ports: [4000],
+  template,
 });
-
-const agent = new HarnessAgent({
-  harness: claudeCode,
-  sandbox: createVercelSandbox({ sandbox: sandboxFromSnapshot }),
-  sandboxConfig,
-});
-
-console.log(preparation.identity);
 ```
 
+The derived template includes the source snapshot ID in its cache key, so
+repeated calls with the same source and template reuse the prepared snapshot.
+Pin mutable Git revisions, image tags, and source URLs when relying on cached
+templates. `sandboxId` names the live sandbox, not its reusable template.
+The existing native `name` option still names the live sandbox; if both are
+supplied, their values must match.
+
 ## Settings
 
 `HarnessAgent` accepts these main settings:
@@ -539,7 +581,6 @@ console.log(preparation.identity);
 - `harness`: the adapter instance.
 - `model`: optional harness-specific model identifier. When omitted, the
   harness uses its default model.
-- `sandbox`: a `HarnessV1SandboxProvider`.
 - `id`: optional stable agent identifier.
 - `instructions`: instructions appended to the runtime's system or developer
   prompt when supported, or prepended to the user prompt otherwise.
@@ -552,6 +593,8 @@ console.log(preparation.identity);
 - `stopWhen`: condition(s) for finishing a result slice after a completed
   harness tool step that can continue into another model step.
 - `tools`: AI SDK tools executed by the host when the harness calls them.
+- `runtimeContext`: application context forwarded to lifecycle callbacks and
+  results for every turn; `prepareCall` can replace it for a new prompt turn.
 - `activeTools`: allowlist of built-in and host-executed tools the harness can
   call.
 - `inactiveTools`: denylist of built-in and host-executed tools the harness
@@ -560,7 +603,9 @@ console.log(preparation.identity);
 - `permissionMode`: built-in tool permission mode.
 - `toolApproval`: approval status map for host-executed tools.
 - `sandboxConfig`: sandbox working-directory and lifecycle hook configuration.
-- `telemetry`, `debug`, and `onLog`: observability and diagnostics.
+- `telemetry`, `debug`, and `onLog`: observability and diagnostics. Use
+  `telemetry.includeRuntimeContext` to allowlist runtime context properties for
+  telemetry.
 
 Telemetry reports each turn's resolved model, instructions, and active
 host-defined tools. Skills are adapter context and do not have a corresponding
@@ -573,26 +618,21 @@ Adapter-specific settings belong on the adapter factory, for example
 
 When your application creates and manages sandboxes itself, prepare the network
 sandbox session first and then pass that same session to `agent.createSession()`.
-The agent does not need a sandbox provider and does not stop or destroy the
+The agent does not create the sandbox and does not stop or destroy the
 caller-owned sandbox.
 
 ```ts
-import { HarnessAgent, prepareSandboxForHarness } from '@ai-sdk/harness/agent';
+import { HarnessAgent } from '@ai-sdk/harness/agent';
 import { claudeCode } from '@ai-sdk/harness-claude-code';
-import { createVercelSandbox } from '@ai-sdk/sandbox-vercel';
+import { createVercelNetworkSandboxSessionFromNativeSandbox } from '@ai-sdk/sandbox-vercel';
 import { Sandbox } from '@vercel/sandbox';
 
 const sandbox = await Sandbox.create({
   runtime: 'node24',
   ports: [4000],
 });
-const sandboxProvider = createVercelSandbox({ sandbox });
-const sandboxSession = await sandboxProvider.createSession();
-
-await prepareSandboxForHarness({
-  session: sandboxSession.restricted(),
-  harnesses: [claudeCode],
-});
+const sandboxSession =
+  createVercelNetworkSandboxSessionFromNativeSandbox(sandbox);
 
 const agent = new HarnessAgent({ harness: claudeCode });
 const session = await agent.createSession({ sandboxSession });
@@ -610,7 +650,7 @@ try {
   }
 } finally {
   await session.destroy();
-  await sandbox.stop();
+  await sandboxSession.destroy();
 }
 ```
 
@@ -627,29 +667,28 @@ configure the bridge port and its externally reachable endpoint on the adapter
 because the basic session cannot resolve them.
 
 ```ts
-import { HarnessAgent, prepareSandboxForHarness } from '@ai-sdk/harness/agent';
+import { HarnessAgent } from '@ai-sdk/harness/agent';
 import { createClaudeCode } from '@ai-sdk/harness-claude-code';
-import { createVercelSandbox } from '@ai-sdk/sandbox-vercel';
+import {
+  createVercelNetworkSandboxSessionFromNativeSandbox,
+  createVercelSandboxSessionFromNativeSandbox,
+} from '@ai-sdk/sandbox-vercel';
 import { Sandbox } from '@vercel/sandbox';
 
 const sandbox = await Sandbox.create({
   runtime: 'node24',
   ports: [4000],
 });
-const sandboxProvider = createVercelSandbox({ sandbox });
-const sandboxSession = await sandboxProvider.createSession();
+const sandboxSession =
+  createVercelNetworkSandboxSessionFromNativeSandbox(sandbox);
 const portEndpoint = await sandboxSession.getPortEndpoint({
   port: 4000,
   protocol: 'ws',
 });
-const restrictedSandboxSession = sandboxSession.restricted();
+const restrictedSandboxSession =
+  createVercelSandboxSessionFromNativeSandbox(sandbox);
 const claudeCode = createClaudeCode({ port: 4000, portEndpoint });
 
-await prepareSandboxForHarness({
-  session: restrictedSandboxSession,
-  harnesses: [claudeCode],
-});
-
 const agent = new HarnessAgent({ harness: claudeCode });
 const session = await agent.createSession({
   sandboxSession: restrictedSandboxSession,
@@ -668,7 +707,7 @@ try {
   }
 } finally {
   await session.destroy();
-  await sandbox.stop();
+  await sandboxSession.destroy();
 }
 ```
 

package/node_modules/{@maka/runtime/node_modules/ai → ai}/docs/03-ai-sdk-harnesses/03-tools.mdx

@@ -25,10 +25,6 @@ the combined tool set through `agent.tools`.
 ```ts
 const agent = new HarnessAgent({
   harness: claudeCode,
-  sandbox: createVercelSandbox({
-    runtime: 'node24',
-    ports: [4000],
-  }),
 });
 
 agent.tools.bash;
@@ -60,7 +56,6 @@ Pass AI SDK tools to `HarnessAgent` the same way you do for a `ToolLoopAgent`:
 ```ts
 import { HarnessAgent } from '@ai-sdk/harness/agent';
 import { claudeCode } from '@ai-sdk/harness-claude-code';
-import { createVercelSandbox } from '@ai-sdk/sandbox-vercel';
 import { tool } from 'ai';
 import { z } from 'zod';
 
@@ -82,10 +77,6 @@ const weather = tool({
 
 const agent = new HarnessAgent({
   harness: claudeCode,
-  sandbox: createVercelSandbox({
-    runtime: 'node24',
-    ports: [4000],
-  }),
   tools: { weather },
 });
 ```
@@ -93,6 +84,53 @@ const agent = new HarnessAgent({
 When the harness calls `weather`, `HarnessAgent` executes the tool in your host
 process, then submits the result back to the harness runtime.
 
+Host-executed tools can declare a `contextSchema` and receive turn-scoped
+context through `toolsContext`:
+
+```ts
+const lookupAccount = tool({
+  inputSchema: z.object({}),
+  contextSchema: z.object({ userId: z.string() }),
+  execute: async (_, { context }) => {
+    return loadAccount(context.userId);
+  },
+});
+
+const agent = new HarnessAgent({
+  harness: claudeCode,
+  tools: { lookupAccount },
+  toolsContext: {
+    lookupAccount: { userId: 'user-123' },
+  },
+});
+```
+
+Use `prepareCall` to replace `toolsContext` when the value depends on custom
+call options. The type of `toolsContext` follows the tool set: it is rejected
+when no tool declares a context schema, required when a tool requires a
+context object, and optional when every context object is optional.
+`HarnessAgent` validates each entry against the tool's `contextSchema` before
+execution and exposes the configured map in step results and lifecycle
+callbacks.
+
+Tool context remains host-only and is not serialized into suspended-turn state.
+When recreating a session for an unfinished turn, rebind it explicitly:
+
+```ts
+const session = await agent.createSession({
+  sessionId,
+  continueFrom,
+  sandboxSession,
+  toolsContext: {
+    lookupAccount: { userId: 'user-123' },
+  },
+});
+```
+
+Missing or invalid context fails validation before the host tool executes. The
+validation error returned to the harness runtime is intentionally generic so
+host-only context values and schema details are not disclosed to the model.
+
 ## Client-Side Tools
 
 Omit `execute` when a browser, user interaction, or another external process
@@ -145,10 +183,6 @@ with `tools`.
 ```ts
 const agent = new HarnessAgent({
   harness: claudeCode,
-  sandbox: createVercelSandbox({
-    runtime: 'node24',
-    ports: [4000],
-  }),
   tools: { weather },
   activeTools: ['weather'],
 });
@@ -159,10 +193,6 @@ const agent = new HarnessAgent({
 ```ts
 const agent = new HarnessAgent({
   harness: claudeCode,
-  sandbox: createVercelSandbox({
-    runtime: 'node24',
-    ports: [4000],
-  }),
   tools: { weather },
   inactiveTools: ['bash', 'write'],
 });
@@ -214,7 +244,6 @@ Use `permissionMode` for adapter-native built-ins:
 ```ts
 const agent = new HarnessAgent({
   harness: pi,
-  sandbox: createVercelSandbox({ runtime: 'node24' }),
   permissionMode: 'allow-edits',
 });
 ```
@@ -233,10 +262,6 @@ Use `toolApproval` for host-executed tools:
 ```ts
 const agent = new HarnessAgent({
   harness: claudeCode,
-  sandbox: createVercelSandbox({
-    runtime: 'node24',
-    ports: [4000],
-  }),
   tools: { weather },
   toolApproval: {
     weather: 'user-approval',

package/node_modules/{@maka/runtime/node_modules/ai → ai}/docs/03-ai-sdk-harnesses/04-skills.mdx

@@ -18,10 +18,6 @@ Pass skills to `HarnessAgent` with the `skills` setting:
 ```ts
 const agent = new HarnessAgent({
   harness: claudeCode,
-  sandbox: createVercelSandbox({
-    runtime: 'node24',
-    ports: [4000],
-  }),
   skills: [
     {
       name: 'careful-refactors',

package/node_modules/{@maka/runtime/node_modules/ai → ai}/docs/03-ai-sdk-harnesses/05-harness-adapters.mdx

@@ -38,10 +38,10 @@ The AI SDK includes the following harness adapters:
 | [Claude Code](/providers/ai-sdk-harnesses/claude-code)       | Sandbox bridge   | <Check />    | <Check />     | <Check />         | <Check />              | <Check />                    |
 | [Cline](/providers/ai-sdk-harnesses/cline)                   | Host process     | <Check />    | <Check />     | <Check />         | <Check />              | <Check />                    |
 | [Codex](/providers/ai-sdk-harnesses/codex)                   | Sandbox bridge   | <Check />    | <Check />     | <Check />         | <Cross />              | <Cross />                    |
-| [Cursor](/providers/ai-sdk-harnesses/cursor)                 | Sandbox via ACP  | <Check />    | <Check />     | <Cross />         | <Check />              | <Cross />                    |
+| [Cursor](/providers/ai-sdk-harnesses/cursor)                 | Sandbox via ACP  | <Check />    | <Check />     | <Cross />         | <Cross />              | <Cross />                    |
 | [Deep Agents](/providers/ai-sdk-harnesses/deepagents)        | Sandbox bridge   | <Check />    | <Check />     | <Check />         | <Check />              | <Check /> via auto-rejection |
 | [fx](/providers/ai-sdk-harnesses/fx)                         | Sandbox via ACP  | <Check />    | <Check />     | <Cross />         | <Check />              | <Cross />                    |
-| [GitHub Copilot](/providers/ai-sdk-harnesses/github-copilot) | Sandbox via ACP  | <Check />    | <Check />     | <Cross />         | <Check />              | <Cross />                    |
-| [Grok Build](/providers/ai-sdk-harnesses/grok-build)         | Sandbox via ACP  | <Check />    | <Check />     | <Check />         | <Check />              | <Cross />                    |
+| [GitHub Copilot](/providers/ai-sdk-harnesses/github-copilot) | Sandbox via ACP  | <Check />    | <Check />     | <Cross />         | <Cross />              | <Cross />                    |
+| [Grok Build](/providers/ai-sdk-harnesses/grok-build)         | Sandbox via ACP  | <Check />    | <Check />     | <Check />         | <Cross />              | <Cross />                    |
 | [OpenCode](/providers/ai-sdk-harnesses/opencode)             | Sandbox bridge   | <Check />    | <Check />     | <Check />         | <Check />              | <Check /> via auto-rejection |
 | [Pi](/providers/ai-sdk-harnesses/pi)                         | Host process     | <Check />    | <Check />     | <Cross />         | <Check />              | <Check />                    |