@myagentroam/agent 0.12.13 → 0.13.0

package/dist/error.d.ts

@@ -9,6 +9,8 @@ export declare class AgentError extends Error {
         cause?: unknown;
     });
 }
+/** Cache stack text before retaining a failure, rather than its lazy callback/receiver frames. */
+export declare function materializeErrorStack(error: unknown): void;
 export declare function describeAgentError(error: unknown, fallbackCode: string, fallbackMessage?: string, includeCauses?: boolean): {
     code: string;
     message: string;

package/dist/error.js

@@ -12,6 +12,16 @@ export class AgentError extends Error {
         this.retryable = options.retryable ?? false;
     }
 }
+/** Cache stack text before retaining a failure, rather than its lazy callback/receiver frames. */
+export function materializeErrorStack(error) {
+    try {
+        if (error instanceof Error)
+            void error.stack;
+    }
+    catch {
+        // A caller's custom stack formatter must not replace the original failure.
+    }
+}
 const MAX_ERROR_MESSAGE_CHARACTERS = 1_000;
 export function describeAgentError(error, fallbackCode, fallbackMessage = 'MAR Agent operation failed.', includeCauses = true) {
     const code = diagnosticCode(error) ?? fallbackCode;

package/dist/extensions/hooks.d.ts

@@ -20,6 +20,8 @@ export declare class ExtensionHooks<Operations extends {
     readonly diagnose: (diagnostic: ExtensionHookDiagnostic) => void;
     readonly callback: ExtensionCallbackRunner;
     constructor(diagnose?: (diagnostic: ExtensionHookDiagnostic) => void, callback?: ExtensionCallbackRunner);
+    /** The Session owner calls this after all registered scopes have drained. */
+    dispose(): void;
     /** Internal physical callback ingress; unrelated dispatch must not inherit reentry suppression. */
     independent<Value>(run: () => Value): Value;
     /** Avoid materializing public views when no active interceptor can consume them. */

package/dist/extensions/hooks.js

@@ -10,6 +10,10 @@ export class ExtensionHooks {
         this.diagnose = diagnose;
         this.callback = callback;
     }
+    /** The Session owner calls this after all registered scopes have drained. */
+    dispose() {
+        this.#active.disable();
+    }
     /** Internal physical callback ingress; unrelated dispatch must not inherit reentry suppression. */
     independent(run) {
         return this.#active.run([], run);

package/dist/extensions/manager.js

@@ -188,7 +188,14 @@ export class ExtensionManager {
             await Promise.all(endings);
             for (const id of this.#sessions.keys())
                 this.retireSession(id);
-            await this.#serial(() => this.#retire());
+            await this.#serial(async () => {
+                try {
+                    await this.#retire();
+                }
+                finally {
+                    this.operations.dispose();
+                }
+            });
         })();
         return this.#disposal;
     }

package/dist/extensions/mcp.d.ts

@@ -79,7 +79,10 @@ export interface ExtensionMcpCompletion {
     readonly toolCount?: number;
 }
 type Run = <Value>(operation: (call: ExtensionOperationContext) => Promise<Value>, signal?: AbortSignal) => Promise<Value>;
-/** One Session's declarations and owned Client leases feed its sole tool registry. */
+/**
+ * One Session's declarations and owned Client leases feed its sole tool registry.
+ * Closed connection refs replay cleanup without owning the released Client.
+ */
 export declare class ExtensionMcp {
     #private;
     readonly tools: ExtensionTools;
@@ -91,6 +94,8 @@ export declare class ExtensionMcp {
     readonly diagnose: () => void;
     readonly validateCatalog: (catalog: McpToolCatalog) => void;
     constructor(tools: ExtensionTools, hooks: Pick<ExtensionHooks<DomainMcpOperations, DomainMcpFacts>, 'invoke' | 'emit'>, getTools: (call: ExtensionOperationContext) => ReadonlyMap<string, ExtensionToolBinding>, toolRef: (binding: ExtensionToolBinding) => ExtensionToolRef, isMcpRef: (ref: ExtensionToolRef) => boolean, invoke: (input: ExtensionToolInvocation, call: ExtensionOperationContext) => Promise<ToolExecutionResult>, diagnose: () => void, validateCatalog: (catalog: McpToolCatalog) => void);
+    /** Connection work and leases are joined by the Session's resource scopes first. */
+    dispose(): void;
     bind(owner: ExtensionResourceScope, extensionId: string, backend: ExtensionMcpBackend, run: Run): ExtensionMcpApi;
     servers(): McpToolCatalog['servers'];
 }

package/dist/extensions/mcp.js

@@ -1,10 +1,13 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { createHash, randomUUID } from 'node:crypto';
 import { isDeepStrictEqual } from 'node:util';
-import { AgentError } from '../error.js';
+import { AgentError, materializeErrorStack } from '../error.js';
 import { cloneCoreJson } from './data.js';
 import { ExtensionResourceScope } from './resources.js';
-/** One Session's declarations and owned Client leases feed its sole tool registry. */
+/**
+ * One Session's declarations and owned Client leases feed its sole tool registry.
+ * Closed connection refs replay cleanup without owning the released Client.
+ */
 export class ExtensionMcp {
     tools;
     hooks;
@@ -29,6 +32,10 @@ export class ExtensionMcp {
         this.diagnose = diagnose;
         this.validateCatalog = validateCatalog;
     }
+    /** Connection work and leases are joined by the Session's resource scopes first. */
+    dispose() {
+        this.#calling.disable();
+    }
     bind(owner, extensionId, backend, run) {
         return {
             register: (definition) => this.#register(owner, extensionId, definition),
@@ -92,14 +99,19 @@ export class ExtensionMcp {
             disconnect: async (input) => {
                 const request = captureInput(input, ['connection', 'signal']);
                 return run((call) => this.hooks.invoke('mcp.disconnect', request, call, async (input, effective) => {
-                    const connection = this.#connectionRefs.get(input.connection);
-                    if (!connection)
+                    const reference = this.#connectionRefs.get(input.connection);
+                    if (!reference)
                         throw new AgentError('MAR_AGENT_MCP_REFERENCE_INVALID', 'MCP connection reference is invalid.');
-                    const active = this.#calling.getStore();
-                    if (active?.active && active.connection === connection)
-                        throw new AgentError('MAR_AGENT_MCP_CONNECTION_BUSY', 'MCP connection cannot close from its active call.');
-                    await connection.registration.dispose();
-                    await this.hooks.emit('mcp.completed', { operation: 'disconnect', connectionId: connection.ref.id }, effective);
+                    const connection = reference.connection;
+                    if (connection) {
+                        const active = this.#calling.getStore();
+                        if (active?.active && active.connection === connection)
+                            throw new AgentError('MAR_AGENT_MCP_CONNECTION_BUSY', 'MCP connection cannot close from its active call.');
+                        await connection.registration.dispose();
+                    }
+                    else
+                        await reference.closing;
+                    await this.hooks.emit('mcp.completed', { operation: 'disconnect', connectionId: input.connection.id }, effective);
                 }), request.signal);
             }
         };
@@ -156,7 +168,7 @@ export class ExtensionMcp {
             call.signal.throwIfAborted();
             await this.#refresh(connection, call);
             call.signal.throwIfAborted();
-            this.#connectionRefs.set(ref, connection);
+            this.#connectionRefs.set(ref, { connection });
             this.#connections.add(connection);
             await this.hooks.emit('mcp.completed', { operation: 'connect', connectionId: ref.id, toolCount: connection.catalog.tools.length }, call);
             return ref;
@@ -312,8 +324,14 @@ export class ExtensionMcp {
                 connection.scope.dispose(),
                 ...connection.sources.map((source) => source.registration.dispose())
             ]);
+            // Captured tool refs may outlive this leaf; no closed ref needs its lease or sibling sources.
+            connection.backend = undefined;
+            connection.sources = [];
+            connection.catalog = { revision: '', servers: [], tools: [] };
+            delete connection.tail;
             const failure = results.find((result) => result.status === 'rejected');
             if (failure?.status === 'rejected') {
+                materializeErrorStack(failure.reason);
                 if (failure.reason instanceof AgentError)
                     throw failure.reason;
                 throw new AgentError('MAR_AGENT_MCP_CLEANUP_FAILED', 'MCP Client lease did not close.', {
@@ -321,6 +339,14 @@ export class ExtensionMcp {
                 });
             }
         })();
+        const reference = this.#connectionRefs.get(connection.ref);
+        if (reference) {
+            reference.closing = connection.closing;
+            const release = () => {
+                delete reference.connection;
+            };
+            void connection.closing.then(release, release);
+        }
         return connection.closing;
     }
     #register(owner, extensionId, input) {
@@ -350,6 +376,7 @@ export class ExtensionMcp {
             const index = this.#declarations.indexOf(entry);
             if (index !== -1)
                 this.#declarations.splice(index, 1);
+            this.#serverRefs.delete(ref);
         });
         this.#declarations.push(entry);
         this.#serverRefs.set(ref, entry);
@@ -369,7 +396,7 @@ export class ExtensionMcp {
         return entry;
     }
     #connection(ref) {
-        const connection = this.#connectionRefs.get(ref);
+        const connection = this.#connectionRefs.get(ref)?.connection;
         if (!connection || connection.closed)
             throw new AgentError('MAR_AGENT_MCP_REFERENCE_INVALID', 'MCP connection is unavailable.');
         return connection;

package/dist/extensions/network.js

@@ -1,4 +1,33 @@
 import { AgentError } from '../error.js';
+/** Closed response facades keep metadata and cleanup outcome, not the transport's callback graph. */
+function responseFacade(lease, resource) {
+    let current = lease;
+    let closed = false;
+    let closing;
+    const close = () => {
+        closed = true;
+        return (closing ??= current?.close() ?? resource.dispose());
+    };
+    const body = {
+        [Symbol.asyncIterator]() {
+            return this;
+        },
+        next: () => closed || !current
+            ? Promise.resolve({ done: true, value: undefined })
+            : current.body[Symbol.asyncIterator]().next(),
+        async return() {
+            await close();
+            return { done: true, value: undefined };
+        }
+    };
+    return {
+        response: { ...lease, body, close },
+        release() {
+            closed = true;
+            current = undefined;
+        }
+    };
+}
 export function bindCoreNetwork(backend, run, scope, hooks, diagnose) {
     return {
         fetch: (input) => run((call) => hooks.invoke('network.fetch', input, call, async (input, effective) => {
@@ -6,15 +35,23 @@ export function bindCoreNetwork(backend, run, scope, hooks, diagnose) {
                 throw new AgentError('MAR_AGENT_HOST_PORT_UNAVAILABLE', 'Native HTTP port is unavailable.');
             const response = await backend.fetch(input, effective);
             let iterator;
+            let done = false;
+            let release = () => { };
             const close = async () => {
+                done = true;
                 // Close the transport first so an in-flight pull is released before iterator cleanup.
-                const results = await Promise.allSettled([
-                    Promise.resolve().then(() => response.close()),
-                    Promise.resolve().then(() => iterator?.return?.())
-                ]);
-                const failure = results.find((result) => result.status === 'rejected');
-                if (failure?.status === 'rejected')
-                    throw failure.reason;
+                try {
+                    const results = await Promise.allSettled([
+                        Promise.resolve().then(() => response.close()),
+                        Promise.resolve().then(() => iterator?.return?.())
+                    ]);
+                    const failure = results.find((result) => result.status === 'rejected');
+                    if (failure?.status === 'rejected')
+                        throw failure.reason;
+                }
+                finally {
+                    release();
+                }
             };
             let registration;
             try {
@@ -33,7 +70,6 @@ export function bindCoreNetwork(backend, run, scope, hooks, diagnose) {
                 throw error;
             }
             const resource = registration;
-            let done = false;
             let nextTail = Promise.resolve();
             const body = {
                 [Symbol.asyncIterator]() {
@@ -80,7 +116,7 @@ export function bindCoreNetwork(backend, run, scope, hooks, diagnose) {
                     throw error;
                 }
             }
-            return {
+            const facade = responseFacade({
                 url: response.url,
                 status: response.status,
                 statusText: response.statusText,
@@ -91,7 +127,11 @@ export function bindCoreNetwork(backend, run, scope, hooks, diagnose) {
                     done = true;
                     await resource.dispose();
                 }
-            };
+            }, resource);
+            release = facade.release;
+            if (done)
+                release();
+            return facade.response;
         }), input.signal)
     };
 }

package/dist/extensions/operation.d.ts

@@ -32,6 +32,8 @@ export type ExtensionOperationRunner = <Value>(operation: (call: ExtensionOperat
 export declare class ExtensionOperations {
     #private;
     current(): ExtensionOperationContext | undefined;
+    /** The Agent owner must join Session and agent-scope work before releasing identity context. */
+    dispose(): void;
     /** Bind the effective owner signal before author code can call another facade. */
     callback<Value>(call: ExtensionOperationContext, callback: (call: ExtensionOperationContext) => Value | Promise<Value>, settled?: boolean): Promise<Value>;
     /** Physical transport ingress starts a new ancestry; native plugin calls cannot choose it. */

package/dist/extensions/operation.js

@@ -7,6 +7,10 @@ export class ExtensionOperations {
         const frame = this.#current.getStore();
         return frame?.active ? frame.context : undefined;
     }
+    /** The Agent owner must join Session and agent-scope work before releasing identity context. */
+    dispose() {
+        this.#current.disable();
+    }
     /** Bind the effective owner signal before author code can call another facade. */
     callback(call, callback, settled = false) {
         const controller = new AbortController();

package/dist/extensions/processes.js

@@ -1,4 +1,4 @@
-import { AgentError } from '../error.js';
+import { AgentError, materializeErrorStack } from '../error.js';
 export function validateCoreProcessInput(input) {
     if (!input ||
         typeof input.executable !== 'string' ||
@@ -31,6 +31,76 @@ function copyProcessInput(input) {
         ...(input.input instanceof Uint8Array ? { input: new Uint8Array(input.input) } : {})
     };
 }
+/** Retain unread pipes while live; after cleanup retain only wait/cancel outcomes. */
+function processFacade(lease, resource) {
+    let current = lease;
+    let completion;
+    let closed = false;
+    let waited = false;
+    let ended = 0;
+    const cancel = () => {
+        closed = true;
+        return resource.dispose();
+    };
+    const finish = () => {
+        if (waited && ended === 2 && !closed)
+            void cancel().catch(() => undefined);
+    };
+    const wait = () => {
+        if (!completion) {
+            completion = current.wait();
+            const settled = () => {
+                waited = true;
+                finish();
+            };
+            void completion.then(settled, (error) => {
+                materializeErrorStack(error);
+                settled();
+            });
+        }
+        return completion;
+    };
+    const stream = (kind) => {
+        let done = false;
+        return {
+            [Symbol.asyncIterator]() {
+                return this;
+            },
+            async next() {
+                if (closed || done || !current)
+                    return { done: true, value: undefined };
+                const next = await current[kind][Symbol.asyncIterator]().next();
+                if (next.done && !done) {
+                    done = true;
+                    ended++;
+                    finish();
+                }
+                return next;
+            },
+            async return() {
+                await cancel();
+                return { done: true, value: undefined };
+            }
+        };
+    };
+    return {
+        handle: {
+            processId: lease.processId,
+            stdout: stream('stdout'),
+            stderr: stream('stderr'),
+            wait,
+            cancel
+        },
+        release() {
+            closed = true;
+            // Join/replay the physical exit even if the first wait comes after cancellation.
+            const detach = () => {
+                current = undefined;
+            };
+            void wait().then(detach, detach);
+        }
+    };
+}
 export function bindCoreProcesses(backend, run, scope, hooks, diagnose) {
     const acquire = async (input, call, emitExit = true) => {
         input = copyProcessInput(input);
@@ -39,33 +109,41 @@ export function bindCoreProcesses(backend, run, scope, hooks, diagnose) {
         let closed = false;
         const iterators = [];
         let pending;
+        let release = () => { };
         const resource = scope.effect(() => async () => {
             closed = true;
-            call.signal.removeEventListener('abort', abort);
-            const handle = await pending.catch(() => undefined);
-            let firstError;
-            let failed = false;
             try {
-                if (typeof handle?.cancel === 'function')
-                    await handle.cancel();
-            }
-            catch (error) {
-                failed = true;
-                firstError = error;
+                call.signal.removeEventListener('abort', abort);
+                const handle = await pending.catch(() => undefined);
+                let firstError;
+                let failed = false;
+                try {
+                    if (typeof handle?.cancel === 'function')
+                        await handle.cancel();
+                }
+                catch (error) {
+                    failed = true;
+                    firstError = error;
+                }
+                const released = await Promise.allSettled(iterators.map((iterator) => Promise.resolve().then(() => iterator.return?.())));
+                const failure = released.find((result) => result.status === 'rejected');
+                if (failed || failure?.status === 'rejected') {
+                    const error = failed
+                        ? firstError
+                        : failure?.status === 'rejected'
+                            ? failure.reason
+                            : undefined;
+                    const cleanupError = new AgentError('MAR_AGENT_PROCESS_CLEANUP_FAILED', 'Native process cleanup failed.', {
+                        details: {
+                            reasonCode: error instanceof AgentError ? error.code : 'BACKEND_CLEANUP_FAILED'
+                        }
+                    });
+                    materializeErrorStack(cleanupError);
+                    throw cleanupError;
+                }
             }
-            const released = await Promise.allSettled(iterators.map((iterator) => Promise.resolve().then(() => iterator.return?.())));
-            const failure = released.find((result) => result.status === 'rejected');
-            if (failed || failure?.status === 'rejected') {
-                const error = failed
-                    ? firstError
-                    : failure?.status === 'rejected'
-                        ? failure.reason
-                        : undefined;
-                throw new AgentError('MAR_AGENT_PROCESS_CLEANUP_FAILED', 'Native process cleanup failed.', {
-                    details: {
-                        reasonCode: error instanceof AgentError ? error.code : 'BACKEND_CLEANUP_FAILED'
-                    }
-                });
+            finally {
+                release();
             }
         });
         const cancel = () => resource.dispose();
@@ -148,7 +226,7 @@ export function bindCoreProcesses(backend, run, scope, hooks, diagnose) {
             };
         };
         let completion;
-        return {
+        const facade = processFacade({
             processId: handle.processId,
             stdout: stream(handle.stdout),
             stderr: stream(handle.stderr),
@@ -164,7 +242,7 @@ export function bindCoreProcesses(backend, run, scope, hooks, diagnose) {
                     throw new AgentError('MAR_AGENT_PROCESS_OUTPUT_INVALID', 'Native process exit result is invalid.');
                 if (emitExit)
                     await hooks.emit('process.completed', { processId: handle.processId, ...exit }, call);
-                return exit;
+                return { code: exit.code, signal: exit.signal };
             }, call.signal)
                 .catch(async (error) => {
                 try {
@@ -175,7 +253,11 @@ export function bindCoreProcesses(backend, run, scope, hooks, diagnose) {
                 }
                 throw error;
             }))
-        };
+        }, resource);
+        release = facade.release;
+        if (closed)
+            release();
+        return facade.handle;
     };
     return {
         spawn: async (input) => {

package/dist/extensions/resources.d.ts

@@ -3,7 +3,10 @@ export interface ExtensionResourceRegistration {
     readonly ready: Promise<void>;
     dispose(): Promise<void>;
 }
-/** An instance's managed resources, not an OS sandbox or a process-wide resource owner. */
+/**
+ * Own one instance's live resources and pending acquisitions, not an OS sandbox or global owner.
+ * Settled handles detach; readiness and cleanup failures remain observable without retaining payloads.
+ */
 export declare class ExtensionResourceScope {
     #private;
     readonly instanceId: `${string}-${string}-${string}-${string}-${string}`;

package/dist/extensions/resources.js

@@ -1,7 +1,49 @@
-import { AgentError } from '../error.js';
+import { AgentError, materializeErrorStack } from '../error.js';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { randomUUID } from 'node:crypto';
-/** An instance's managed resources, not an OS sandbox or a process-wide resource owner. */
+/** Own one acquisition and release without retaining its payload or former owner after disposal. */
+function createResourceRegistration(acquire, settled) {
+    let release;
+    const ready = Promise.resolve()
+        .then(acquire)
+        .then((disposer) => {
+        if (typeof disposer !== 'function')
+            throw new AgentError('MAR_AGENT_EXTENSION_RESOURCE_INVALID', 'Resource acquisition must return a disposer.');
+        release = disposer;
+    });
+    let releasing;
+    const disposalFrame = new AsyncLocalStorage();
+    const finish = (failed) => {
+        disposalFrame.disable();
+        const notify = settled;
+        settled = undefined;
+        notify?.(failed);
+    };
+    return {
+        ready,
+        dispose: () => {
+            if (disposalFrame.getStore())
+                return Promise.resolve();
+            releasing ??= ready
+                .then(async () => {
+                const dispose = release;
+                release = undefined;
+                if (dispose)
+                    await disposalFrame.run(true, dispose);
+            }, () => undefined)
+                .then(() => finish(false), (error) => {
+                materializeErrorStack(error);
+                finish(true);
+                throw error;
+            });
+            return releasing;
+        }
+    };
+}
+/**
+ * Own one instance's live resources and pending acquisitions, not an OS sandbox or global owner.
+ * Settled handles detach; readiness and cleanup failures remain observable without retaining payloads.
+ */
 export class ExtensionResourceScope {
     instanceId = randomUUID();
     static #initialization = new AsyncLocalStorage();
@@ -21,7 +63,10 @@ export class ExtensionResourceScope {
     }
     #state = 'STAGED';
     #controller = new AbortController();
-    #resources = [];
+    #resources = new Set();
+    #acquisitions = new Set();
+    #acquisitionFailure;
+    #cleanupFailures = 0;
     #operations = new Set();
     #activators = new Set();
     #disposal;
@@ -42,31 +87,24 @@ export class ExtensionResourceScope {
     }
     effect(acquire) {
         this.#assertOpen();
-        const acquired = Promise.resolve()
-            .then(acquire)
-            .then((release) => {
-            if (typeof release !== 'function')
-                throw new AgentError('MAR_AGENT_EXTENSION_RESOURCE_INVALID', 'Resource acquisition must return a disposer.');
-            return release;
+        const registration = createResourceRegistration(acquire, (failed) => {
+            this.#resources.delete(registration);
+            if (failed)
+                this.#cleanupFailures++;
         });
-        let releasing;
-        const disposalFrame = new AsyncLocalStorage();
-        const registration = {
-            ready: acquired.then(() => undefined),
-            dispose: () => {
-                if (disposalFrame.getStore())
-                    return Promise.resolve();
-                releasing ??= acquired.then(async (release) => {
-                    if (typeof release !== 'function')
-                        throw new AgentError('MAR_AGENT_EXTENSION_RESOURCE_INVALID', 'Resource acquisition must return a disposer.');
-                    await disposalFrame.run(true, release);
-                }, () => undefined);
-                return releasing;
-            }
-        };
-        // Acquisition errors remain observable through ready, without unhandled rejection noise.
-        void registration.ready.catch(() => undefined);
-        this.#resources.push(registration);
+        const ready = registration.ready;
+        this.#acquisitions.add(ready);
+        // Readiness keeps the first acquisition failure, not a history of completed registrations.
+        void ready.then(() => {
+            this.#acquisitions.delete(ready);
+        }, (error) => {
+            this.#acquisitions.delete(ready);
+            materializeErrorStack(error);
+            this.#acquisitionFailure ??= { error };
+            // A failed acquisition owns no resource, even when its caller never explicitly disposes it.
+            void registration.dispose();
+        });
+        this.#resources.add(registration);
         return registration;
     }
     async run(operation, parent) {
@@ -126,11 +164,10 @@ export class ExtensionResourceScope {
     }
     /** Wait for acquisitions added by setup before publishing any callbacks. */
     async ready() {
-        let count = -1;
-        while (count !== this.#resources.length) {
-            count = this.#resources.length;
-            await Promise.all(this.#resources.map((resource) => resource.ready));
-        }
+        while (this.#acquisitions.size)
+            await Promise.all([...this.#acquisitions]);
+        if (this.#acquisitionFailure)
+            throw this.#acquisitionFailure.error;
     }
     retire() {
         if (this.#state === 'DISPOSED')
@@ -169,8 +206,15 @@ export class ExtensionResourceScope {
                             onError(error);
                     })
                         .finally(() => {
-                        if (repeat)
+                        if (stopped || !repeat || this.#state !== 'ACTIVE')
+                            callbacks.disable();
+                        else
                             schedule();
+                        if (!repeat)
+                            // Join running before releasing the one-shot registration; never await ourselves.
+                            void running
+                                .then(() => registration.dispose(), () => registration.dispose())
+                                .catch(() => undefined);
                     });
                     void running.catch(() => undefined);
                 }, Math.min(Math.max(0, due - performance.now()), 2_147_483_647));
@@ -184,8 +228,15 @@ export class ExtensionResourceScope {
             if (timer !== undefined)
                 clearTimeout(timer);
             timerController.abort();
-            if (!callbacks.getStore())
-                await running;
+            // A callback releasing itself must retain its context until running settles.
+            if (!callbacks.getStore()) {
+                try {
+                    await running;
+                }
+                finally {
+                    callbacks.disable();
+                }
+            }
         });
         if (this.#state === 'ACTIVE')
             schedule();
@@ -199,15 +250,15 @@ export class ExtensionResourceScope {
         this.retire();
         this.#disposal = Promise.resolve().then(async () => {
             await Promise.allSettled([...this.#operations]);
-            let failures = 0;
             for (const resource of [...this.#resources].reverse()) {
                 try {
                     await resource.dispose();
                 }
                 catch {
-                    failures++;
+                    // Each registration records its failure once, including earlier manual disposal.
                 }
             }
+            const failures = this.#cleanupFailures;
             if (failures)
                 throw new AgentError('MAR_AGENT_EXTENSION_CLEANUP_FAILED', 'Extension resource cleanup failed.', { details: { failures } });
             this.#state = 'DISPOSED';

package/dist/extensions/session-input.d.ts

@@ -129,7 +129,10 @@ export interface SessionInputEntry {
 }
 /** Internal writer evidence survives errors after commit, without settling the operation early. */
 export declare function recordSessionInputCommit(entry: SessionInputEntry, outcome: ExtensionSessionActionResult): void;
-/** One Session FIFO shared by native writes and the existing parent mailbox. No model loop. */
+/**
+ * One Session FIFO shared by native writes and the parent mailbox. No model loop.
+ * Active entries own requests and callbacks; settled history owns only public receipts.
+ */
 export declare class SessionInputCoordinator {
     #private;
     readonly diagnose: (receipt: ExtensionSessionReceipt) => void;

package/dist/extensions/session-input.js

@@ -20,11 +20,15 @@ export function recordSessionInputCommit(entry, outcome) {
         ...(committed.executionId === undefined ? {} : { executionId: committed.executionId })
     };
 }
-/** One Session FIFO shared by native writes and the existing parent mailbox. No model loop. */
+/**
+ * One Session FIFO shared by native writes and the parent mailbox. No model loop.
+ * Active entries own requests and callbacks; settled history owns only public receipts.
+ */
 export class SessionInputCoordinator {
     diagnose;
     #pending = [];
     #records = [];
+    #active = new Set();
     #current = new AsyncLocalStorage();
     #sequence = 0;
     #closed = false;
@@ -155,10 +159,7 @@ export class SessionInputCoordinator {
         validateCoreSessionRequest(request);
         let complete;
         let started;
-        const entry = {
-            request: structuredClone(request),
-            source,
-            action,
+        const record = {
             receipt: {
                 operationId: source.operationId || randomUUID(),
                 sequence: ++this.#sequence,
@@ -167,6 +168,17 @@ export class SessionInputCoordinator {
                 ...(source.ownerInstanceId ? { ownerInstanceId: source.ownerInstanceId } : {}),
                 ...(source.extensionId ? { extensionId: source.extensionId } : {}),
                 ...(source.parentOperationId ? { parentOperationId: source.parentOperationId } : {})
+            }
+        };
+        const entry = {
+            request: structuredClone(request),
+            source,
+            action,
+            get receipt() {
+                return record.receipt;
+            },
+            set receipt(value) {
+                record.receipt = value;
             },
             started: new Promise((resolve) => {
                 started = resolve;
@@ -186,7 +198,8 @@ export class SessionInputCoordinator {
                 this.#finish(entry, 'cancelled');
         };
         source.signal.addEventListener('abort', abort, { once: true });
-        this.#records.push(entry);
+        this.#active.add(entry);
+        this.#records.push(record);
         this.#trim();
         return entry;
     }
@@ -314,18 +327,21 @@ export class SessionInputCoordinator {
     }
     async idle() {
         await this.#draining;
-        await Promise.all(this.#records
+        await Promise.all([...this.#active]
             .filter((entry) => entry.receipt.status === 'in-progress')
             .map((entry) => entry.terminal));
     }
     async retire(instanceId) {
         if (!instanceId)
             this.#closed = true;
-        const owned = this.#records.filter((entry) => !instanceId || entry.source.ownerInstanceId === instanceId);
+        const owned = [...this.#active].filter((entry) => !instanceId || entry.receipt.ownerInstanceId === instanceId);
         for (const entry of owned)
             if (entry.receipt.status === 'queued' || entry.receipt.status === 'accepted')
                 this.#finish(entry, 'cancelled');
         await Promise.all(owned.filter((entry) => entry.receipt.status === 'in-progress').map((entry) => entry.terminal));
+        // Retiring one extension must not clear another extension's in-flight input context.
+        if (!instanceId)
+            this.#current.disable();
     }
     startExecution(entry, executionId) {
         entry.receipt = { ...entry.receipt, executionId };
@@ -336,7 +352,7 @@ export class SessionInputCoordinator {
         if (this.#settled.size > 200)
             this.#settled.delete(this.#settled.keys().next().value);
         for (const entry of this.#records)
-            if (entry.request.kind === 'submit' &&
+            if (entry.receipt.kind === 'submit' &&
                 entry.receipt.executionId === executionId &&
                 entry.receipt.status === 'committed')
                 entry.receipt = { ...entry.receipt, status };
@@ -361,6 +377,10 @@ export class SessionInputCoordinator {
                 entry.receipt = { ...entry.receipt, status: settled };
         }
         entry.complete();
+        this.#active.delete(entry);
+        const pending = this.#pending.indexOf(entry);
+        if (pending !== -1)
+            this.#pending.splice(pending, 1);
         if (status === 'failed')
             this.diagnose(Object.freeze({ ...entry.receipt }));
         this.#trim();
@@ -368,7 +388,7 @@ export class SessionInputCoordinator {
     #trim() {
         while (this.#records.length > 200) {
             const index = this.#records.findIndex((entry) => !['queued', 'accepted', 'in-progress'].includes(entry.receipt.status) &&
-                !(entry.receipt.status === 'committed' && entry.request.kind === 'submit'));
+                !(entry.receipt.status === 'committed' && entry.receipt.kind === 'submit'));
             if (index === -1)
                 break;
             this.#records.splice(index, 1);

package/dist/extensions/session-tools.d.ts

@@ -4,7 +4,10 @@ import type { ExtensionOperationContext, ExtensionOperationRunner, ExtensionOper
 import { ExtensionResourceScope } from './resources.js';
 import type { ExtensionToolRuntime } from './tool-runtime.js';
 import { ExtensionTools, type ExtensionToolsApi, type ExtensionToolBinding, type ExtensionToolRef, type ExtensionToolInvocation, type ExtensionToolCheck, type DomainToolOperations, type DomainToolFacts } from './tools.js';
-/** One Session's tool catalog, references, attempt lineage, and invocation frames. */
+/**
+ * Own one Session's tool catalog, attempt lineage, and invocation frames.
+ * References retain captured bindings only until their source owner has drained its scoped work.
+ */
 export declare class ExtensionSessionTools {
     #private;
     private readonly toolRuntime;
@@ -18,6 +21,8 @@ export declare class ExtensionSessionTools {
     constructor(toolRuntime: ExtensionToolRuntime, operations: Pick<ExtensionOperations, 'callback' | 'continue'>, hooks: Pick<ExtensionHooks<DomainToolOperations, DomainToolFacts>, 'invoke' | 'emit'>, baseTools: (context?: ExtensionOperationContext) => readonly ExtensionToolBinding[], allowTool: (name: string, definition?: ExtensionToolBinding['definition']) => boolean, scheduleTool: <T>(definition: ExtensionToolBinding['definition'], run: () => Promise<T>) => Promise<T>, assertLive: () => void, isRetired: () => boolean);
     readonly tools: ExtensionTools;
     private get toolFrame();
+    /** Release propagation only after the Session owner has joined all scoped tool work. */
+    dispose(): void;
     withTools<T>(bindings: ReadonlyMap<string, ExtensionToolBinding>, schedule: <Value>(definition: ExtensionToolBinding['definition'], run: () => Promise<Value>) => Promise<Value>, run: () => T): T;
     independent<T>(run: () => T): T;
     isMcp(ref: ExtensionToolRef): boolean;

package/dist/extensions/session-tools.js

@@ -4,7 +4,10 @@ import { isDeepStrictEqual } from 'node:util';
 import { AgentError } from '../error.js';
 import { ExtensionResourceScope } from './resources.js';
 import { ExtensionTools } from './tools.js';
-/** One Session's tool catalog, references, attempt lineage, and invocation frames. */
+/**
+ * Own one Session's tool catalog, attempt lineage, and invocation frames.
+ * References retain captured bindings only until their source owner has drained its scoped work.
+ */
 export class ExtensionSessionTools {
     toolRuntime;
     operations;
@@ -25,6 +28,8 @@ export class ExtensionSessionTools {
         this.isRetired = isRetired;
     }
     #toolRefs = new WeakMap();
+    #ownerToolRefs = new Map();
+    #sessionToolRefs = { bindings: new WeakMap() };
     tools = new ExtensionTools((binding, stage) => Object.freeze({
         ...binding,
         invoke: (input, call) => this.toolAttempt(input, call, stage, async () => {
@@ -47,6 +52,15 @@ export class ExtensionSessionTools {
         const frame = this.#toolFrame.getStore();
         return frame?.active ? frame : undefined;
     }
+    /** Release propagation only after the Session owner has joined all scoped tool work. */
+    dispose() {
+        this.#attempt.disable();
+        this.#toolFrame.disable();
+        // Host/Session refs outlive individual extensions, but never the Session owner.
+        this.#toolRefs = new WeakMap();
+        this.#ownerToolRefs.clear();
+        this.#sessionToolRefs.bindings = new WeakMap();
+    }
     withTools(bindings, schedule, run) {
         this.assertLive();
         const frame = { bindings, schedule, active: true };
@@ -70,9 +84,15 @@ export class ExtensionSessionTools {
         return this.#toolFrame.run(undefined, () => this.#attempt.run(undefined, run));
     }
     isMcp(ref) {
-        return this.#toolRefs.get(ref)?.mcp !== undefined;
+        return this.#referenceBinding(ref)?.mcp !== undefined;
     }
     bind(scope, extensionId, run, current) {
+        const refs = { bindings: new WeakMap() };
+        this.#ownerToolRefs.set(scope.instanceId, refs);
+        scope.effect(() => () => {
+            // Keep an empty index for this owner so late snapshots cannot acquire Session lifetime.
+            refs.bindings = undefined;
+        });
         return {
             register: (spec) => this.tools.register(scope, extensionId, spec),
             catalog: () => Object.freeze([...this.capture(current()).values()].map((binding) => this.toolRef(binding))),
@@ -86,9 +106,16 @@ export class ExtensionSessionTools {
             source: binding.source,
             ...(binding.mcp === undefined ? {} : { mcp: binding.mcp })
         });
-        this.#toolRefs.set(ref, binding);
+        const refs = binding.referenceIndex ??
+            this.#ownerToolRefs.get(binding.source.instanceId ?? '') ??
+            this.#sessionToolRefs;
+        refs.bindings?.set(ref, binding);
+        this.#toolRefs.set(ref, refs);
         return ref;
     }
+    #referenceBinding(ref) {
+        return this.#toolRefs.get(ref)?.bindings?.get(ref);
+    }
     capture(context, includeStaged = false, base) {
         this.assertLive();
         if (!base && !includeStaged && this.toolFrame)
@@ -217,7 +244,7 @@ export class ExtensionSessionTools {
         const snapshot = this.capture(context);
         if (!call.ref)
             return snapshot;
-        const binding = this.#toolRefs.get(call.ref);
+        const binding = this.#referenceBinding(call.ref);
         if (!binding || binding.definition.name !== call.name)
             throw new AgentError('MAR_AGENT_TOOL_NOT_AVAILABLE', 'Tool reference is unavailable.');
         return new Map([...snapshot, [call.name, binding]]);

package/dist/extensions/session.js

@@ -245,6 +245,9 @@ export class ExtensionSession {
                 failures++;
             }
         }
+        this.mcp.dispose();
+        this.#toolDomain.dispose();
+        this.hooks.dispose();
         if (failures)
             throw new AgentError('MAR_AGENT_EXTENSION_CLEANUP_FAILED', 'Session extension cleanup failed.', { details: { failures } });
     }

package/dist/extensions/tools.d.ts

@@ -41,7 +41,12 @@ export interface ExtensionToolFailure extends ExtensionToolAttempt {
     readonly status: 'failed' | 'cancelled';
     readonly errorCode: string;
 }
+/** Internal reference storage, released only by the source owner after its work has drained. */
+export interface ExtensionToolReferenceIndex {
+    bindings: WeakMap<ExtensionToolRef, ExtensionToolBinding> | undefined;
+}
 export interface ExtensionToolBinding extends ExtensionToolRef {
+    readonly referenceIndex?: ExtensionToolReferenceIndex;
     readonly mcp?: McpCatalogTool;
     registered?(): boolean;
     available?(context: ExtensionOperationContext): boolean;

package/dist/extensions/tools.js

@@ -116,87 +116,8 @@ export class ExtensionTools {
                     continue;
                 throw new AgentError('MAR_AGENT_EXTENSION_DEPENDENCY_MISSING', 'Tool wrapper has no lower implementation.');
             }
-            const definition = copyDefinition(entry.spec);
-            definition.allowedCallers ??= lower
-                ? (lower.definition.allowedCallers ??
-                    (lower.source.kind === 'mcp' ? ['direct', 'programmatic'] : ['direct']))
-                : ['direct', 'programmatic'];
-            if (entry.spec.override === 'wrap' && lower?.definition.agentScope !== undefined)
-                definition.agentScope ??= lower.definition.agentScope;
-            if (entry.spec.override === 'wrap' && lower?.definition.codeModeExposure !== undefined)
-                definition.codeModeExposure ??= lower.definition.codeModeExposure;
-            const binding = Object.freeze({
-                definition: deepFreeze(definition),
-                ...(entry.spec.override === 'wrap' && lower?.mcp ? { mcp: lower.mcp } : {}),
-                source: Object.freeze({
-                    kind: 'extension',
-                    id: entry.id,
-                    revision: entry.revision,
-                    instanceId: entry.owner.instanceId
-                }),
-                available: () => entry.owner.state === 'ACTIVE' ||
-                    (entry.owner.state === 'STAGED' && ExtensionResourceScope.initializing),
-                invoke: async (call, context) => entry.owner.run((signal) => this.callback(Object.freeze({
-                    ...context,
-                    signal,
-                    extensionId: entry.id,
-                    ownerInstanceId: entry.owner.instanceId
-                }), async (context) => {
-                    const signal = context.signal;
-                    const approvedArguments = context.permission === undefined ? undefined : structuredClone(call.arguments);
-                    const input = await entry.parse(call.arguments);
-                    const { permission: _permission, ...unapproved } = context;
-                    const parsedContext = context.permission !== undefined && !isDeepStrictEqual(input, approvedArguments)
-                        ? unapproved
-                        : context;
-                    signal.throwIfAborted();
-                    const controller = new AbortController();
-                    const effective = AbortSignal.any([signal, controller.signal]);
-                    const pending = new Set();
-                    let open = true;
-                    let output;
-                    try {
-                        output = await entry.spec.execute(input, Object.freeze({
-                            ...parsedContext,
-                            signal: effective,
-                            ownerInstanceId: entry.owner.instanceId
-                        }), (input) => {
-                            const result = Promise.resolve().then(() => {
-                                effective.throwIfAborted();
-                                if (!open)
-                                    throw new AgentError('MAR_AGENT_TOOL_NOT_AVAILABLE', 'Tool continuation has finished.');
-                                if (!lower || entry.spec.override !== 'wrap')
-                                    throw new AgentError('MAR_AGENT_EXTENSION_DEPENDENCY_MISSING', 'Tool has no wrapper continuation.');
-                                return lower.invoke({ ...call, arguments: input }, Object.freeze({
-                                    ...(parsedContext.permission !== undefined &&
-                                        isDeepStrictEqual(input, approvedArguments)
-                                        ? parsedContext
-                                        : unapproved),
-                                    signal: effective
-                                }));
-                            });
-                            const settled = result.then(() => undefined, () => undefined);
-                            pending.add(settled);
-                            void settled.then(() => pending.delete(settled));
-                            return result;
-                        });
-                    }
-                    catch (error) {
-                        controller.abort();
-                        throw error;
-                    }
-                    finally {
-                        while (pending.size)
-                            await Promise.all([...pending]);
-                        open = false;
-                    }
-                    if (!output || typeof output.content !== 'string')
-                        throw new AgentError('MAR_AGENT_TOOL_OUTPUT_INVALID', 'Tool result must contain string content.');
-                    await entry.validateOutput?.(output.data);
-                    return output;
-                }), context.signal)
-            });
-            bindings.set(definition.name, this.trace(binding, entry.spec.override === 'wrap' ? 'wrapper' : 'leaf'));
+            const binding = this.#bindContribution(entry, lower);
+            bindings.set(binding.definition.name, this.trace(binding, entry.spec.override === 'wrap' ? 'wrapper' : 'leaf'));
         }
         const view = Object.freeze({
             get size() {
@@ -215,6 +136,92 @@ export class ExtensionTools {
         });
         return view;
     }
+    /** Do not let a retained replacement close over the capture's unrelated source map. */
+    #bindContribution(entry, lower) {
+        const definition = copyDefinition(entry.spec);
+        const continuation = entry.spec.override === 'wrap' ? lower : undefined;
+        definition.allowedCallers ??= lower
+            ? (lower.definition.allowedCallers ??
+                (lower.source.kind === 'mcp' ? ['direct', 'programmatic'] : ['direct']))
+            : ['direct', 'programmatic'];
+        if (entry.spec.override === 'wrap' && lower?.definition.agentScope !== undefined)
+            definition.agentScope ??= lower.definition.agentScope;
+        if (entry.spec.override === 'wrap' && lower?.definition.codeModeExposure !== undefined)
+            definition.codeModeExposure ??= lower.definition.codeModeExposure;
+        const binding = Object.freeze({
+            definition: deepFreeze(definition),
+            ...(continuation?.referenceIndex ? { referenceIndex: continuation.referenceIndex } : {}),
+            ...(entry.spec.override === 'wrap' && lower?.mcp ? { mcp: lower.mcp } : {}),
+            source: Object.freeze({
+                kind: 'extension',
+                id: entry.id,
+                revision: entry.revision,
+                instanceId: entry.owner.instanceId
+            }),
+            available: () => entry.owner.state === 'ACTIVE' ||
+                (entry.owner.state === 'STAGED' && ExtensionResourceScope.initializing),
+            invoke: async (call, context) => entry.owner.run((signal) => this.callback(Object.freeze({
+                ...context,
+                signal,
+                extensionId: entry.id,
+                ownerInstanceId: entry.owner.instanceId
+            }), async (context) => {
+                const signal = context.signal;
+                const approvedArguments = context.permission === undefined ? undefined : structuredClone(call.arguments);
+                const input = await entry.parse(call.arguments);
+                const { permission: _permission, ...unapproved } = context;
+                const parsedContext = context.permission !== undefined && !isDeepStrictEqual(input, approvedArguments)
+                    ? unapproved
+                    : context;
+                signal.throwIfAborted();
+                const controller = new AbortController();
+                const effective = AbortSignal.any([signal, controller.signal]);
+                const pending = new Set();
+                let open = true;
+                let output;
+                try {
+                    output = await entry.spec.execute(input, Object.freeze({
+                        ...parsedContext,
+                        signal: effective,
+                        ownerInstanceId: entry.owner.instanceId
+                    }), (input) => {
+                        const result = Promise.resolve().then(() => {
+                            effective.throwIfAborted();
+                            if (!open)
+                                throw new AgentError('MAR_AGENT_TOOL_NOT_AVAILABLE', 'Tool continuation has finished.');
+                            if (!continuation)
+                                throw new AgentError('MAR_AGENT_EXTENSION_DEPENDENCY_MISSING', 'Tool has no wrapper continuation.');
+                            return continuation.invoke({ ...call, arguments: input }, Object.freeze({
+                                ...(parsedContext.permission !== undefined &&
+                                    isDeepStrictEqual(input, approvedArguments)
+                                    ? parsedContext
+                                    : unapproved),
+                                signal: effective
+                            }));
+                        });
+                        const settled = result.then(() => undefined, () => undefined);
+                        pending.add(settled);
+                        void settled.then(() => pending.delete(settled));
+                        return result;
+                    });
+                }
+                catch (error) {
+                    controller.abort();
+                    throw error;
+                }
+                finally {
+                    while (pending.size)
+                        await Promise.all([...pending]);
+                    open = false;
+                }
+                if (!output || typeof output.content !== 'string')
+                    throw new AgentError('MAR_AGENT_TOOL_OUTPUT_INVALID', 'Tool result must contain string content.');
+                await entry.validateOutput?.(output.data);
+                return output;
+            }), context.signal)
+        });
+        return binding;
+    }
 }
 function schemaValidator(schema, code) {
     let validator;

package/dist/runtime/compaction/coordinator.js

@@ -57,6 +57,7 @@ export class CompactCoordinator {
                 flight.settled = true;
                 ready();
                 controller.signal.removeEventListener('abort', abort);
+                this.#owner.disable();
             }
         });
         // The result remains observable at the next checkpoint, including asynchronous failures.

package/dist/sdk/extension-tools.d.ts

@@ -2,7 +2,10 @@ import type { ExtensionToolBinding } from '../extensions/tools.js';
 import type { ClientToolDefinition, McpToolCatalog } from '../tools/contracts.js';
 import { type RoundToolScope } from '../tools/execution.js';
 import type { ToolRuntimeContext } from '../tools/runtime-context.js';
-/** One real Execution's sources; a retained physical frame is distinct from its active main round. */
+/**
+ * Own one real Execution's sources and native-reference index.
+ * Retained physical frames outlive the main round; release references only after the last one drains.
+ */
 export declare class ExecutionToolSources {
     #private;
     readonly executionId: string;

package/dist/sdk/extension-tools.js

@@ -4,14 +4,19 @@ import { AgentError } from '../error.js';
 import { toolCallers } from '../tools/callers.js';
 import { createRoundToolRuntimeContext } from '../tools/execution.js';
 import { executeCapturedTool } from '../tools/runtime.js';
-/** One real Execution's sources; a retained physical frame is distinct from its active main round. */
+/**
+ * Own one real Execution's sources and native-reference index.
+ * Retained physical frames outlive the main round; release references only after the last one drains.
+ */
 export class ExecutionToolSources {
     executionId;
     sessionId;
     bindings;
+    #referenceIndex = { bindings: new WeakMap() };
     #frame = new AsyncLocalStorage();
     #scope;
     #closed = false;
+    #frames = 0;
     constructor(executionId, sessionId, definitions, builtins, catalog, supplemental = []) {
         this.executionId = executionId;
         this.sessionId = sessionId;
@@ -26,6 +31,7 @@ export class ExecutionToolSources {
                 });
                 return Object.freeze({
                     definition,
+                    referenceIndex: this.#referenceIndex,
                     source: Object.freeze({
                         kind,
                         id: mcp?.sourceIdentity ?? `${kind}:${executionId}:${definition.name}`,
@@ -86,19 +92,29 @@ export class ExecutionToolSources {
     withFrame(context, run) {
         if (context.executionId !== this.executionId || context.sessionId !== this.sessionId)
             throw unavailable();
+        // A later retained call gets a fresh index, never the refs released by an earlier frame.
+        this.#referenceIndex.bindings ??= new WeakMap();
         const frame = { context, active: true };
+        this.#frames++;
+        const finish = () => {
+            frame.active = false;
+            if (--this.#frames === 0 && this.#closed) {
+                this.#referenceIndex.bindings = undefined;
+                this.#frame.disable();
+            }
+        };
         return this.#frame.run(frame, () => {
             try {
                 const result = run();
                 if (result instanceof Promise)
                     return result.finally(() => {
-                        frame.active = false;
+                        finish();
                     });
-                frame.active = false;
+                finish();
                 return result;
             }
             catch (error) {
-                frame.active = false;
+                finish();
                 throw error;
             }
         });
@@ -106,6 +122,11 @@ export class ExecutionToolSources {
     close() {
         this.#closed = true;
         this.#scope = undefined;
+        // Retained physical callbacks may outlive the main round and must keep their own frame.
+        if (this.#frames === 0) {
+            this.#referenceIndex.bindings = undefined;
+            this.#frame.disable();
+        }
     }
     #context(call) {
         if (call.executionId !== this.executionId || call.sessionId !== this.sessionId)

package/dist/tools/scheduler.js

@@ -7,11 +7,13 @@ export function withIndependentSessionTools(run) {
 /** One barrier domain for foreground tools and all retained cells in a Session. */
 export function createSessionToolScheduler() {
     const leases = new AsyncLocalStorage();
+    let activeJobs = 0;
     const definitions = [
         { name: 'safe', parallelSafety: 'safe' },
         { name: 'serial', parallelSafety: 'serial' }
     ];
     const execute = async (job) => {
+        activeJobs++;
         const lease = {
             active: true,
             ingress: sessionToolIngress.getStore(),
@@ -27,6 +29,8 @@ export function createSessionToolScheduler() {
                 while (lease.children.size)
                     await Promise.all([...lease.children]);
                 lease.active = false;
+                if (--activeJobs === 0)
+                    leases.disable();
             }
         });
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/agent",
-  "version": "0.12.13",
+  "version": "0.13.0",
   "description": "Embeddable MAR coding agent SDK and CLI.",
   "license": "Apache-2.0",
   "type": "module",