@fungi.computer/mycelium 0.1.0 → 0.2.0

package/dist/internal/host-cores.node.js

@@ -0,0 +1,5 @@
+import { availableParallelism } from "node:os";
+/** Node's maintained, affinity-aware observation; captured by runtime policy. */
+export function availableHostCores() {
+    return availableParallelism();
+}

package/dist/mcp-catalog.d.ts

@@ -6,12 +6,6 @@ export type McpCatalogSnapshot = Readonly<{
     sources: readonly CapabilitySource[];
     /** Every permitted module is named; an omitted module is refused. */
     grants: Grants;
-    /**
-     * Granted modules whose writes a person already approved for this principal,
-     * such as an owner's stored approval of a key's App tools. Their writes run
-     * without a per-call elicitation; every other write still asks.
-     */
-    approvedWrites?: readonly string[];
 }>;
 /**
  * Adapt principal-scoped capability sources and a sandbox to the shared MCP server.

package/dist/mcp-catalog.js

@@ -41,7 +41,6 @@ export function createMcpCatalog(options) {
                         ...access,
                         defaultGrant: "none",
                         sessionGrants: () => snapshot?.grants ?? {},
-                        approvedWrites: () => snapshot?.approvedWrites ?? [],
                     },
                 });
                 try {

package/dist/mcp.d.ts

@@ -28,7 +28,6 @@ export type McpExecutionContext = Readonly<{
     }>) => Promise<void>;
     /** Apply to Mycelium access options for this call only; never persist callbacks. */
     access: Pick<AccessOptions, "confirm"> & Readonly<{
-        confirmWrites: true;
         /** Recheck the open connection and refresh authority before each operation. */
         beforeCall: (signal: AbortSignal) => Promise<void>;
     }>;

package/dist/mcp.js

@@ -73,7 +73,6 @@ export function createMcp(options) {
                     }
                     : undefined;
                 const access = {
-                    confirmWrites: true,
                     confirm,
                     beforeCall: async (signal) => {
                         signal.throwIfAborted();

package/dist/output-collector.d.ts

@@ -0,0 +1,46 @@
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+/** Complete decoded text, in completion order across stdout/stderr, not byte order. */
+export declare class OutputCollector {
+    #private;
+    private readonly wake;
+    private constructor();
+    static make(): Effect.Effect<OutputCollector, never, never>;
+    /** Never waits for a reader. An incomplete scalar stays with its producer. */
+    write(stream: "stdout" | "stderr", bytes: Uint8Array): void;
+    snapshot(): {
+        tail: string;
+        droppedBytes: number;
+        totalBytes: number;
+    };
+    /** EOF flush order is stdout then stderr; the final update precedes terminal. */
+    finish(): {
+        type: "update";
+        result: {
+            isError: false;
+            content: {
+                type: "text";
+                text: string;
+            }[];
+            data: {
+                droppedBytes: number;
+                totalBytes: number;
+            };
+        };
+    } | undefined;
+    get updates(): Stream.Stream<{
+        type: "update";
+        result: {
+            isError: false;
+            content: {
+                type: "text";
+                text: string;
+            }[];
+            data: {
+                droppedBytes: number;
+                totalBytes: number;
+            };
+        };
+    }, never, never>;
+    dispose(): void;
+}

package/dist/output-collector.js

@@ -0,0 +1,145 @@
+import * as Effect from "effect/Effect";
+import * as Queue from "effect/Queue";
+import * as Stream from "effect/Stream";
+const capacity = 8192;
+const encoder = new TextEncoder();
+// fatal: false is the existing default; Cloudflare's type requires the field.
+const decoder = () => new TextDecoder("utf-8", { ignoreBOM: true, fatal: false });
+/** Complete decoded text, in completion order across stdout/stderr, not byte order. */
+export class OutputCollector {
+    wake;
+    #producers = {
+        stdout: { decoder: decoder(), pendingBytes: 0 },
+        stderr: { decoder: decoder(), pendingBytes: 0 },
+    };
+    #probe = decoder();
+    // One bounded ring of complete decoder emissions. No UTF-8 slicing/parser.
+    #parts = Array.from({ length: capacity }, () => undefined);
+    #head = 0;
+    #size = 0;
+    #textBytes = 0;
+    #newlines = 0;
+    #droppedBytes = 0;
+    #totalBytes = 0;
+    #dirty = false;
+    #closed = false;
+    constructor(wake) {
+        this.wake = wake;
+    }
+    static make() {
+        return Queue.make({ capacity: 1, strategy: "dropping" }).pipe(Effect.map((wake) => new OutputCollector(wake)));
+    }
+    /** Never waits for a reader. An incomplete scalar stays with its producer. */
+    write(stream, bytes) {
+        if (this.#closed || bytes.length === 0)
+            return;
+        const producer = this.#producers[stream];
+        this.#totalBytes += bytes.length;
+        // Byte-sized decoder inputs let each retained emission carry its exact raw
+        // cost, even when malformed input expands to replacement characters.
+        for (let i = 0; i < bytes.length; i++) {
+            const byte = bytes.subarray(i, i + 1);
+            producer.pendingBytes++;
+            const text = producer.decoder.decode(byte, { stream: true });
+            if (text.length === 0)
+                continue;
+            // A decoder may emit a replacement for a prior incomplete sequence while
+            // buffering the current byte as the start of the next scalar. Ask the
+            // maintained decoder, rather than duplicating UTF-8 byte grammar.
+            const pending = producer.pendingBytes > 1 &&
+                this.#probe.decode(byte, { stream: true }).length === 0
+                ? 1
+                : 0;
+            this.#probe.decode();
+            this.#append(text, producer.pendingBytes - pending);
+            producer.pendingBytes = pending;
+        }
+        this.#dirty = true;
+        Queue.offerUnsafe(this.wake, undefined);
+    }
+    #evict() {
+        const part = this.#parts[this.#head];
+        if (part === undefined)
+            throw new Error("Missing output ring entry");
+        this.#parts[this.#head] = undefined;
+        this.#head = (this.#head + 1) % capacity;
+        this.#size--;
+        this.#textBytes -= part.textBytes;
+        this.#newlines -= part.newlines;
+        this.#droppedBytes += part.rawBytes;
+    }
+    #append(text, rawBytes) {
+        if (text.length === 0)
+            return;
+        const part = {
+            text,
+            rawBytes,
+            textBytes: encoder.encode(text).length,
+            newlines: text.split("\n").length - 1,
+        };
+        if (this.#size === capacity)
+            this.#evict();
+        this.#parts[(this.#head + this.#size) % capacity] = part;
+        this.#size++;
+        this.#textBytes += part.textBytes;
+        this.#newlines += part.newlines;
+        while (this.#textBytes > capacity || this.#newlines >= 200)
+            this.#evict();
+    }
+    snapshot() {
+        let tail = "";
+        for (let i = 0; i < this.#size; i++) {
+            const part = this.#parts[(this.#head + i) % capacity];
+            if (part === undefined)
+                throw new Error("Missing output ring entry");
+            tail += part.text;
+        }
+        return {
+            tail,
+            droppedBytes: this.#droppedBytes,
+            totalBytes: this.#totalBytes,
+        };
+    }
+    #update() {
+        if (!this.#dirty)
+            return undefined;
+        this.#dirty = false;
+        const { tail, ...data } = this.snapshot();
+        return {
+            type: "update",
+            result: {
+                isError: false,
+                content: [{ type: "text", text: tail }],
+                data,
+            },
+        };
+    }
+    /** EOF flush order is stdout then stderr; the final update precedes terminal. */
+    finish() {
+        if (this.#closed)
+            return undefined;
+        this.#closed = true;
+        for (const producer of [this.#producers.stdout, this.#producers.stderr]) {
+            const text = producer.decoder.decode();
+            this.#append(text, producer.pendingBytes);
+            producer.pendingBytes = 0;
+            if (text.length > 0)
+                this.#dirty = true;
+        }
+        return this.#update();
+    }
+    get updates() {
+        return Stream.fromQueue(this.wake).pipe(Stream.mapEffect(() => Effect.sleep("100 millis").pipe(Effect.map(() => (this.#closed ? undefined : this.#update())))), Stream.filter((part) => part !== undefined));
+    }
+    dispose() {
+        this.#closed = true;
+        this.#parts.fill(undefined);
+        this.#head = this.#size = this.#textBytes = this.#newlines = 0;
+        this.#totalBytes = this.#droppedBytes = 0;
+        this.#dirty = false;
+        for (const producer of [this.#producers.stdout, this.#producers.stderr]) {
+            producer.decoder.decode();
+            producer.pendingBytes = 0;
+        }
+    }
+}

package/dist/runtime.js

@@ -36,13 +36,13 @@ function settleClosePlans(plans, liveRevisions) {
 export function openCoreRuntime(options) {
     return Effect.gen(function* () {
         const gate = yield* Semaphore.make(1);
-        const backingWork = createBackingWorkTracker();
         const execution = yield* Effect.try({
             try: () => normalizeExecutionPolicy(options.execution),
             catch: (cause) => cause instanceof MyceliumDefinitionError
                 ? cause
                 : new MyceliumDefinitionError("Execution policy is invalid"),
         });
+        const backingWork = yield* createBackingWorkTracker(execution.capacity);
         const sandbox = Object.freeze({
             execute: options.sandbox.execute,
             adapter: options.sandbox.adapter,

package/dist/sandbox-admission.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+export declare const sandboxAdmissionOptionsSchema: z.ZodObject<{
+    sandboxCapacity: z.ZodOptional<z.ZodInt>;
+    admissionWaitMs: z.ZodOptional<z.ZodInt>;
+}, z.core.$strict>;
+/** Host-owned admission inputs; never part of guest execute arguments. */
+export type SandboxAdmissionOptions = Readonly<{
+    /** Positive host-selected capacity; omission derives the host default. */
+    sandboxCapacity?: number | undefined;
+    /** Maximum admission wait in milliseconds, from 1 through 900,000. */
+    admissionWaitMs?: number | undefined;
+}>;
+/** Captured once per runtime and shared across backing-work groups. */
+export type SandboxAdmissionPolicy = Readonly<{
+    capacity: number;
+    waitMs: number;
+}>;
+/** Validate host policy and resolve defaults from a platform-owned core observation. */
+export declare function normalizeSandboxAdmissionPolicy(options: SandboxAdmissionOptions | undefined, availableCores?: number): SandboxAdmissionPolicy;

package/dist/sandbox-admission.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { MyceliumDefinitionError } from "./errors.js";
+export const sandboxAdmissionOptionsSchema = z.strictObject({
+    sandboxCapacity: z.int().positive().optional(),
+    admissionWaitMs: z.int().min(1).max(900_000).optional(),
+});
+/** Validate host policy and resolve defaults from a platform-owned core observation. */
+export function normalizeSandboxAdmissionPolicy(options, availableCores) {
+    const parsed = sandboxAdmissionOptionsSchema.safeParse(options ?? {});
+    const cores = z
+        .int()
+        .positive()
+        .safeParse(availableCores ?? 2);
+    if (!parsed.success || !cores.success) {
+        throw new MyceliumDefinitionError("Sandbox admission policy is invalid");
+    }
+    return Object.freeze({
+        capacity: parsed.data.sandboxCapacity ?? Math.min(32, Math.max(2, cores.data)),
+        waitMs: parsed.data.admissionWaitMs ?? 5_000,
+    });
+}

package/dist/sandbox-boundary.js

@@ -4,11 +4,12 @@ import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
 import { z } from "zod";
 import { InvalidOperationInput } from "./errors.js";
-import { SourceInvalid, GuestThrew, DeadlineExceeded, Cancelled, DispatchLost, SandboxCrashed, BadResponse, ResultTooLarge, ResultNotJson, CapabilityFailed, Unknown, referenceSandboxFailure, sandboxFailureMessage, } from "./sandbox-failure.js";
+import { SourceInvalid, GuestThrew, DeadlineExceeded, SandboxBusy, Cancelled, DispatchLost, SandboxCrashed, BadResponse, ResultTooLarge, ResultNotJson, CapabilityFailed, Unknown, referenceSandboxFailure, sandboxFailureMessage, } from "./sandbox-failure.js";
 const ownedFailureSchema = z.lazy(() => z.union([
     z.instanceof(SourceInvalid),
     z.instanceof(GuestThrew),
     z.instanceof(DeadlineExceeded),
+    z.instanceof(SandboxBusy),
     z.instanceof(Cancelled),
     z.instanceof(DispatchLost),
     z.instanceof(SandboxCrashed),
@@ -175,6 +176,7 @@ const transportEnvelopeSchema = z.lazy(() => z.strictObject({
         "SourceInvalid",
         "GuestThrew",
         "DeadlineExceeded",
+        "SandboxBusy",
         "Cancelled",
         "DispatchLost",
         "SandboxCrashed",

package/dist/sandbox-failure-event.d.ts

@@ -7,7 +7,7 @@ export declare const SandboxFailureEventSchema: Schema.Struct<{
     readonly executionId: Schema.String;
     readonly adapter: Schema.String;
     readonly buildSha: Schema.NullOr<Schema.String>;
-    readonly tag: Schema.Literals<readonly ["SourceInvalid", "GuestThrew", "DeadlineExceeded", "Cancelled", "DispatchLost", "SandboxCrashed", "BadResponse", "ResultTooLarge", "ResultNotJson", "CapabilityFailed", "Unknown"]>;
+    readonly tag: Schema.Literals<readonly ["SourceInvalid", "GuestThrew", "DeadlineExceeded", "SandboxBusy", "Cancelled", "DispatchLost", "SandboxCrashed", "BadResponse", "ResultTooLarge", "ResultNotJson", "CapabilityFailed", "Unknown"]>;
     readonly fields: Schema.$Record<Schema.String, Schema.Codec<z.core.util.JSONType, z.core.util.JSONType, never, never>>;
     readonly healthAlert: Schema.Boolean;
 }>;

package/dist/sandbox-failure-event.js

@@ -20,6 +20,7 @@ export const SandboxFailureEventSchema = Schema.Struct({
         "SourceInvalid",
         "GuestThrew",
         "DeadlineExceeded",
+        "SandboxBusy",
         "Cancelled",
         "DispatchLost",
         "SandboxCrashed",

package/dist/sandbox-failure.d.ts

@@ -34,6 +34,17 @@ export declare class DeadlineExceeded extends DeadlineExceeded_base<SandboxFailu
     readonly acknowledged?: boolean | undefined;
 }> {
 }
+declare const SandboxBusy_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "SandboxBusy";
+} & Readonly<A>;
+/** Admission expired before any sandbox work started. */
+export declare class SandboxBusy extends SandboxBusy_base<SandboxFailureReference & {
+    readonly capacity: number;
+    readonly waitedMs: number;
+}> {
+    /** Stable contention code, not a sandbox health failure. */
+    readonly code = "sandbox-busy";
+}
 declare const Cancelled_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
     readonly _tag: "Cancelled";
 } & Readonly<A>;
@@ -120,7 +131,7 @@ export declare class Unknown extends Unknown_base<SandboxFailureReference & {
 }> {
 }
 /** Closed error channel shared by sandbox adapters and the invocation owner. */
-export type SandboxFailure = SourceInvalid | GuestThrew | DeadlineExceeded | Cancelled | DispatchLost | SandboxCrashed | BadResponse | ResultTooLarge | ResultNotJson | CapabilityFailed | Unknown;
+export type SandboxFailure = SourceInvalid | GuestThrew | DeadlineExceeded | SandboxBusy | Cancelled | DispatchLost | SandboxCrashed | BadResponse | ResultTooLarge | ResultNotJson | CapabilityFailed | Unknown;
 /** Copy the failure to correlate one execution without mutating shared host errors. */
 export declare function referenceSandboxFailure(failure: SandboxFailure, ref: string): SandboxFailure;
 /** The sole model projection. Transport, parser and raw cause fields stay private. */

package/dist/sandbox-failure.js

@@ -8,6 +8,11 @@ export class GuestThrew extends Data.TaggedError("GuestThrew") {
 /** The invocation owner decided its execution budget was spent. */
 export class DeadlineExceeded extends Data.TaggedError("DeadlineExceeded") {
 }
+/** Admission expired before any sandbox work started. */
+export class SandboxBusy extends Data.TaggedError("SandboxBusy") {
+    /** Stable contention code, not a sandbox health failure. */
+    code = "sandbox-busy";
+}
 /** The invocation owner accepted cancellation. */
 export class Cancelled extends Data.TaggedError("Cancelled") {
 }
@@ -62,6 +67,12 @@ export function referenceSandboxFailure(failure, ref) {
                 acknowledged: failure.acknowledged,
                 ref,
             });
+        case "SandboxBusy":
+            return new SandboxBusy({
+                capacity: failure.capacity,
+                waitedMs: failure.waitedMs,
+                ref,
+            });
         case "Cancelled":
             return new Cancelled({
                 by: failure.by,
@@ -126,6 +137,9 @@ export function sandboxFailureMessage(failure, includeReference = true) {
         case "DeadlineExceeded":
             text = `execute hit its ${String(failure.limitMs)} ms deadline after ${String(failure.elapsedMs)} ms; split the work or persist progress${failure.acknowledged === false ? "; sandbox did not acknowledge cancellation" : ""}`;
             break;
+        case "SandboxBusy":
+            text = `sandbox-busy: all ${String(failure.capacity)} sandbox slots remained occupied after waiting ${String(failure.waitedMs)} ms. Nothing ran; retry this call after capacity becomes available.`;
+            break;
         case "Cancelled":
             text =
                 failure.acknowledged === false

package/dist/sandbox-wire.d.ts

@@ -20,6 +20,11 @@ export declare const sandboxWireSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"deadline_exceeded">;
         limitMs: z.ZodNumber;
         elapsedMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"sandbox_busy">;
+        code: z.ZodLiteral<"sandbox-busy">;
+        capacity: z.ZodInt;
+        waitedMs: z.ZodNumber;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"result_not_json">;
         valueKind: z.ZodString;

package/dist/sandbox-wire.js

@@ -1,6 +1,6 @@
 import { sandboxOperatorValue, sandboxGuestFailure, } from "./sandbox-boundary.js";
 import { z } from "zod";
-import { SourceInvalid, DeadlineExceeded, ResultNotJson, SandboxCrashed, BadResponse, DispatchLost, Cancelled, ResultTooLarge, CapabilityFailed, Unknown, } from "./sandbox-failure.js";
+import { SourceInvalid, DeadlineExceeded, SandboxBusy, ResultNotJson, SandboxCrashed, BadResponse, DispatchLost, Cancelled, ResultTooLarge, CapabilityFailed, Unknown, } from "./sandbox-failure.js";
 /** The host-to-host result contract; raw diagnostic fields never go to guest code. */
 export const sandboxWireSchema = z.discriminatedUnion("ok", [
     z.strictObject({ ok: z.literal(true), value: z.json() }),
@@ -24,6 +24,12 @@ export const sandboxWireSchema = z.discriminatedUnion("ok", [
                 limitMs: z.number().int().positive(),
                 elapsedMs: z.number().nonnegative(),
             }),
+            z.strictObject({
+                kind: z.literal("sandbox_busy"),
+                code: z.literal("sandbox-busy"),
+                capacity: z.int().positive(),
+                waitedMs: z.number().nonnegative(),
+            }),
             z.strictObject({
                 kind: z.literal("result_not_json"),
                 valueKind: z.string().max(80),
@@ -82,6 +88,11 @@ export function sandboxWireFailure(error) {
             return sandboxGuestFailure(error);
         case "deadline_exceeded":
             return new DeadlineExceeded(error);
+        case "sandbox_busy":
+            return new SandboxBusy({
+                capacity: error.capacity,
+                waitedMs: error.waitedMs,
+            });
         case "result_not_json":
             return new ResultNotJson({
                 kind: error.valueKind,
@@ -131,6 +142,14 @@ export function sandboxFailureWire(failure) {
                 elapsedMs: failure.elapsedMs,
             };
             break;
+        case "SandboxBusy":
+            error = {
+                kind: "sandbox_busy",
+                code: failure.code,
+                capacity: failure.capacity,
+                waitedMs: failure.waitedMs,
+            };
+            break;
         case "Cancelled":
             error = { kind: "cancelled", by: failure.by };
             break;

package/docs/api/index.md

@@ -378,7 +378,6 @@ type AccessOptions = Readonly<{
   sessionGrants?: (context) => Grants;
   beforeCall?: (signal) => Promise<void>;
   confirmWrites?: boolean;
-  approvedWrites?: (context) => readonly string[];
   confirm?: (request, signal) => Promise<boolean>;
   onRefused?: (refusal, context) => void;
 }>;
@@ -387,7 +386,8 @@ type AccessOptions = Readonly<{
 Host-supplied access data and the one way to ask a person. Every field is
 optional: hosted defaults allow unnamed modules, and no `confirm` means an
 operation requiring approval is refused, never run unasked. MCP catalogs
-explicitly default unnamed modules to none and require approval for writes.
+explicitly default unnamed modules to none. Native hosts own durable approval
+policy for admitted writes; explicit author confirmation still uses this port.
 
 ---
 
@@ -503,10 +503,11 @@ Closed failure vocabulary for the first Mycelium runtime slice.
 type ExecutionOptions = Readonly<{
   timeoutMs?: number;
   abortGraceMs?: number;
-}>;
+}> &
+  SandboxAdmissionOptions;
 ```
 
-Host-selectable execution limits; neither budget can be disabled.
+Host execution limits plus the reserved, host-only admission contract.
 
 ---
 
@@ -515,7 +516,7 @@ Host-selectable execution limits; neither budget can be disabled.
 ```ts
 type CollectedImage = Readonly<{
   data: string;
-  mimeType: "image/jpeg" | "image/png" | "image/webp";
+  mimeType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
   path: string;
   bytes: number;
 }>;
@@ -543,10 +544,14 @@ The collector as one execution's operations see it: push only.
 type InvocationContext = Readonly<{
   executionId: string;
   toolCallId?: string;
+  operationOrdinal?: number;
   toolCallCode?: string;
   deadlineAt: number | null;
   signal: AbortSignal;
   images?: ExecutionImages;
+  output?: Readonly<{
+    write: (stream, bytes) => void;
+  }>;
 }>;
 ```
 
@@ -835,6 +840,32 @@ Asked before every call of a gated module's operations.
 
 ---
 
+### SandboxAdmissionOptions
+
+```ts
+type SandboxAdmissionOptions = Readonly<{
+  sandboxCapacity?: number;
+  admissionWaitMs?: number;
+}>;
+```
+
+Host-owned admission inputs; never part of guest execute arguments.
+
+---
+
+### SandboxAdmissionPolicy
+
+```ts
+type SandboxAdmissionPolicy = Readonly<{
+  capacity: number;
+  waitMs: number;
+}>;
+```
+
+Captured once per runtime and shared across backing-work groups.
+
+---
+
 ### SandboxFailureEvent
 
 ```ts
@@ -925,6 +956,7 @@ const SandboxFailureEventSchema: Struct<{
       "SourceInvalid",
       "GuestThrew",
       "DeadlineExceeded",
+      "SandboxBusy",
       "Cancelled",
       "DispatchLost",
       "SandboxCrashed",
@@ -942,6 +974,31 @@ const SandboxFailureEventSchema: Struct<{
 
 Shared structural grammar for durable operator facts and client inspection.
 
+## Functions
+
+### normalizeSandboxAdmissionPolicy()
+
+```ts
+function normalizeSandboxAdmissionPolicy(
+  options,
+  availableCores?,
+): SandboxAdmissionPolicy;
+```
+
+Validate host policy and resolve defaults from a platform-owned core
+observation.
+
+#### Parameters
+
+| Parameter         | Type                                                                                              |
+| ----------------- | ------------------------------------------------------------------------------------------------- |
+| `options`         | \| `Readonly`\<\{ `sandboxCapacity?`: `number`; `admissionWaitMs?`: `number`; \}\> \| `undefined` |
+| `availableCores?` | `number`                                                                                          |
+
+#### Returns
+
+[`SandboxAdmissionPolicy`](#sandboxadmissionpolicy)
+
 ## References
 
 ### sandboxFailure
@@ -1010,6 +1067,12 @@ Re-exports [DeadlineExceeded](sandbox-failure.md#deadlineexceeded)
 
 ---
 
+### SandboxBusy
+
+Re-exports [SandboxBusy](sandbox-failure.md#sandboxbusy)
+
+---
+
 ### Cancelled
 
 Re-exports [Cancelled](sandbox-failure.md#cancelled)

package/docs/api/mcp.md

@@ -44,7 +44,6 @@ type McpCatalogSnapshot = Readonly<{
   instructions: string;
   sources: readonly CapabilitySource[];
   grants: Grants;
-  approvedWrites?: readonly string[];
 }>;
 ```
 
@@ -93,7 +92,6 @@ type McpExecutionContext = Readonly<{
   onPart?: (part) => Promise<void>;
   access: Pick<AccessOptions, "confirm"> &
     Readonly<{
-      confirmWrites: true;
       beforeCall: (signal) => Promise<void>;
     }>;
 }>;