@khorsheed/dsh-local-agent 0.1.0-rc.6

package/lib/types/member-control.d.ts

@@ -0,0 +1,62 @@
+import type { LocalAgentAppliedConfiguration, LocalAgentControlReceipt, LocalAgentMemberConfiguration, LocalAgentMemberControlState, LocalAgentResolvedConfiguration } from './types.ts';
+export interface MemberControlRecord {
+    state: LocalAgentMemberControlState;
+    requests: Record<string, {
+        signature: string;
+        receipt: LocalAgentControlReceipt;
+    }>;
+}
+/** write must commit atomically or throw; no accepted receipt precedes durable storage. */
+export interface MemberControlStorage {
+    read(memberId: string): MemberControlRecord | undefined;
+    write(memberId: string, record: MemberControlRecord): void;
+}
+export type { MemberConfigurationAdapter } from './types.ts';
+import type { MemberConfigurationAdapter } from './types.ts';
+/**
+ * One durable, replaceable configuration slot. Intent acceptance never waits
+ * for a running model turn or an in-flight native control. Native effects are
+ * serialized separately and must converge before the next admission.
+ */
+export declare class MemberConfigurationController {
+    readonly memberId: string;
+    private readonly storage;
+    private readonly adapter;
+    private record;
+    private recovering;
+    private worker;
+    private activeLease;
+    private admitting;
+    private storageFailure;
+    private readonly listeners;
+    constructor(memberId: string, storage: MemberControlStorage, adapter: MemberConfigurationAdapter, initial: {
+        selection: LocalAgentMemberConfiguration;
+        resolved?: LocalAgentResolvedConfiguration;
+        lockedReason?: string;
+    });
+    read(): LocalAgentMemberControlState;
+    /** A failed pre-prompt native binding requires reconciliation before another admission. */
+    rejectAdmission(error: unknown): void;
+    private change;
+    private receipt;
+    private duplicate;
+    private validRequestId;
+    select(requestId: string, expectedRevision: number, selection: LocalAgentMemberConfiguration): Promise<LocalAgentControlReceipt>;
+    cancel(requestId: string, expectedRevision: number): LocalAgentControlReceipt;
+    /** Failed intent stays in place. Retry first reconciles the uncertain operation. */
+    retry(expectedRevision: number): Promise<void>;
+    private kick;
+    private work;
+    private completeOperation;
+    private preparedSelection;
+    private assertFrozen;
+    private reconcile;
+    private drain;
+    /** The returned immutable lease belongs to one entire model/tool round. */
+    admit(roundId: string): Promise<{
+        configuration: LocalAgentAppliedConfiguration;
+        release: () => void;
+    }>;
+    follow(signal: AbortSignal): AsyncIterable<LocalAgentMemberControlState>;
+}
+//# sourceMappingURL=member-control.d.ts.map

package/lib/types/member-control.js

@@ -0,0 +1,359 @@
+function normalize(selection) {
+    const choice = (value) => {
+        if (value?.mode === 'inherit' || value?.mode === 'default')
+            return { mode: value.mode };
+        if (value?.mode === 'value' && typeof value.value === 'string' && value.value.trim() !== '' && !/[\r\n\0]/.test(value.value)) {
+            return { mode: 'value', value: value.value.trim() };
+        }
+        throw new Error('Invalid model or effort selection');
+    };
+    return { model: choice(selection?.model), effort: choice(selection?.effort) };
+}
+/**
+ * One durable, replaceable configuration slot. Intent acceptance never waits
+ * for a running model turn or an in-flight native control. Native effects are
+ * serialized separately and must converge before the next admission.
+ */
+export class MemberConfigurationController {
+    memberId;
+    storage;
+    adapter;
+    record;
+    recovering;
+    worker;
+    activeLease = false;
+    admitting = false;
+    storageFailure;
+    listeners = new Set();
+    constructor(memberId, storage, adapter, initial) {
+        this.memberId = memberId;
+        this.storage = storage;
+        this.adapter = adapter;
+        const existing = storage.read(memberId);
+        this.recovering = existing !== undefined;
+        this.record = existing ?? {
+            state: { memberId, revision: 0, current: { revision: 0, selection: normalize(initial.selection), resolved: initial.resolved ?? {} }, status: 'idle', ...initial.lockedReason === undefined ? {} : { lockedReason: initial.lockedReason } },
+            requests: {},
+        };
+        if (this.record.state.memberId !== memberId)
+            throw new Error('Member control identity mismatch');
+        if (existing === undefined)
+            storage.write(memberId, this.record);
+    }
+    read() {
+        const state = structuredClone(this.record.state);
+        return this.storageFailure === undefined ? state : { ...state, status: 'failed', error: this.storageFailure.message };
+    }
+    /** A failed pre-prompt native binding requires reconciliation before another admission. */
+    rejectAdmission(error) {
+        this.recovering = true;
+        if (this.storageFailure !== undefined || this.record.state.status === 'failed')
+            return;
+        this.change(record => {
+            record.state.status = 'failed';
+            record.state.error = error instanceof Error ? error.message : 'Native round admission failed';
+        });
+    }
+    change(mutate) {
+        const next = structuredClone(this.record);
+        mutate(next);
+        try {
+            this.storage.write(this.memberId, next);
+        }
+        catch (error) {
+            this.storageFailure = error instanceof Error ? error : new Error('Member configuration could not be persisted');
+            throw this.storageFailure;
+        }
+        this.storageFailure = undefined;
+        this.record = next;
+        for (const listener of this.listeners)
+            listener();
+    }
+    receipt(requestId, status, error) {
+        return { requestId, revision: this.record.state.revision, status, ...error === undefined ? {} : { error } };
+    }
+    duplicate(requestId, signature) {
+        const existing = Object.hasOwn(this.record.requests, requestId) ? this.record.requests[requestId] : undefined;
+        return existing === undefined ? undefined : existing.signature === signature
+            ? structuredClone(existing.receipt) : this.receipt(requestId, 'conflict', 'Request ID was already used for a different operation');
+    }
+    validRequestId(requestId) {
+        return typeof requestId === 'string' && requestId.length > 0 && requestId.length <= 160
+            && !Object.hasOwn(Object.prototype, requestId) && !/[\r\n\0]/.test(requestId);
+    }
+    async select(requestId, expectedRevision, selection) {
+        if (!this.validRequestId(requestId))
+            return this.receipt(requestId, 'unsupported', 'Invalid control request ID');
+        let next;
+        try {
+            next = normalize(selection);
+        }
+        catch (error) {
+            return this.receipt(requestId, 'unsupported', String(error));
+        }
+        const signature = JSON.stringify(['select', next]);
+        const duplicate = this.duplicate(requestId, signature);
+        if (duplicate !== undefined)
+            return duplicate;
+        const locked = this.record.state.lockedReason;
+        if (locked !== undefined)
+            return this.receipt(requestId, 'locked', locked);
+        if (this.record.state.revision !== expectedRevision)
+            return this.receipt(requestId, 'conflict', 'Configuration changed; refresh before submitting');
+        try {
+            await this.adapter.validate(next);
+        }
+        catch (error) {
+            return this.receipt(requestId, 'unsupported', error instanceof Error ? error.message : String(error));
+        }
+        // Validation yields; admission or another entrance may have changed state.
+        const repeated = this.duplicate(requestId, signature);
+        if (repeated !== undefined)
+            return repeated;
+        if (this.record.state.revision !== expectedRevision)
+            return this.receipt(requestId, 'conflict', 'Configuration changed during validation');
+        this.change(record => {
+            const state = record.state;
+            const previous = state.pending;
+            if (previous !== undefined && previous.revision !== state.operation?.revision) {
+                const receipt = record.requests[previous.requestId]?.receipt;
+                if (receipt !== undefined) {
+                    receipt.status = 'cancelled';
+                    receipt.error = 'Replaced by a newer selection';
+                }
+            }
+            state.revision++;
+            state.pending = { revision: state.revision, requestId, kind: 'selection', selection: next };
+            state.status = 'pending';
+            delete state.error;
+            record.requests[requestId] = { signature, receipt: { requestId, revision: state.revision, status: 'pending' } };
+        });
+        this.kick();
+        return structuredClone(this.record.requests[requestId].receipt);
+    }
+    cancel(requestId, expectedRevision) {
+        if (!this.validRequestId(requestId))
+            return this.receipt(requestId, 'unsupported', 'Invalid control request ID');
+        const signature = JSON.stringify(['cancel', expectedRevision]);
+        const duplicate = this.duplicate(requestId, signature);
+        if (duplicate !== undefined)
+            return duplicate;
+        if (this.record.state.revision !== expectedRevision)
+            return this.receipt(requestId, 'conflict', 'Pending selection changed; refresh before cancelling');
+        if (this.record.state.pending === undefined)
+            return this.receipt(requestId, 'applied', 'The selection has already applied');
+        this.change(record => {
+            const state = record.state;
+            const previous = state.pending;
+            const old = record.requests[previous.requestId]?.receipt;
+            if (old !== undefined)
+                old.status = 'cancelled';
+            state.revision++;
+            delete state.error;
+            if (state.operation === undefined) {
+                delete state.pending;
+                state.status = 'idle';
+            }
+            else {
+                // An older control is already on the wire. Restore the last applied
+                // selection before releasing admission, even if that older ack lands.
+                state.pending = { revision: state.revision, requestId, kind: 'cancel', selection: structuredClone(state.current.selection) };
+                state.status = 'pending';
+            }
+            record.requests[requestId] = { signature, receipt: { requestId, revision: state.revision, status: state.pending === undefined ? 'cancelled' : 'pending' } };
+        });
+        this.kick();
+        return structuredClone(this.record.requests[requestId].receipt);
+    }
+    /** Failed intent stays in place. Retry first reconciles the uncertain operation. */
+    retry(expectedRevision) {
+        if (this.record.state.revision !== expectedRevision)
+            return Promise.reject(new Error('Configuration revision conflict'));
+        if (this.record.state.status !== 'failed' && this.storageFailure === undefined)
+            return this.worker ?? Promise.resolve();
+        this.change(record => { record.state.status = record.state.pending === undefined ? 'idle' : 'pending'; delete record.state.error; });
+        this.recovering = true;
+        return this.work();
+    }
+    kick() {
+        if (!this.activeLease && !this.admitting)
+            void this.work().catch(() => { });
+    }
+    work() {
+        if (this.worker !== undefined)
+            return this.worker;
+        const worker = this.drain();
+        this.worker = worker;
+        const clear = () => {
+            if (this.worker !== worker)
+                return;
+            this.worker = undefined;
+            if (this.record.state.pending !== undefined && this.record.state.status !== 'failed' && !this.activeLease && this.storageFailure === undefined)
+                this.kick();
+        };
+        void worker.then(clear, clear);
+        return worker;
+    }
+    completeOperation(record, resolved) {
+        const operation = record.state.operation;
+        record.state.current = { revision: operation.revision, selection: operation.selection, resolved };
+        const receipt = record.requests[operation.requestId]?.receipt;
+        if (receipt !== undefined)
+            receipt.status = operation.kind === 'cancel' ? 'cancelled' : 'applied';
+        if (record.state.pending?.revision === operation.revision)
+            delete record.state.pending;
+        delete record.state.operation;
+        record.state.status = record.state.pending === undefined ? 'idle' : 'pending';
+        delete record.state.error;
+    }
+    preparedSelection() {
+        const frozen = this.record.state.frozen;
+        const selection = structuredClone(frozen?.selection ?? this.record.state.current.selection);
+        if (frozen?.resolved.model !== undefined)
+            selection.model = { mode: 'value', value: frozen.resolved.model };
+        if (frozen?.resolved.effort !== undefined)
+            selection.effort = { mode: 'value', value: frozen.resolved.effort };
+        return selection;
+    }
+    assertFrozen(resolved) {
+        const frozen = this.record.state.frozen;
+        if (frozen !== undefined && (resolved.model !== frozen.resolved.model || resolved.effort !== frozen.resolved.effort)) {
+            throw new Error('Frozen evaluation configuration changed; admission is blocked');
+        }
+    }
+    async reconcile() {
+        this.change(record => { record.state.status = 'reconciling'; });
+        const snapshot = this.read();
+        if (snapshot.frozen !== undefined)
+            snapshot.current = { ...snapshot.frozen, selection: this.preparedSelection() };
+        const inspected = await this.adapter.reconcile(snapshot);
+        this.assertFrozen(inspected.resolved);
+        if (inspected.active)
+            throw new Error('The native session still has an active round');
+        if (inspected.matches === 'unknown' || (inspected.matches === 'operation' && this.record.state.operation === undefined)) {
+            throw new Error('Native configuration could not be reconciled; admission remains blocked');
+        }
+        this.change(record => {
+            if (inspected.matches === 'operation')
+                this.completeOperation(record, inspected.resolved);
+            else {
+                record.state.current.resolved = inspected.resolved;
+                delete record.state.operation;
+                record.state.status = record.state.pending === undefined ? 'idle' : 'pending';
+            }
+            delete record.state.round;
+            delete record.state.error;
+        });
+        this.recovering = false;
+    }
+    async drain() {
+        if (this.activeLease)
+            return;
+        if (this.storageFailure !== undefined)
+            throw this.storageFailure;
+        if (this.record.state.status === 'failed')
+            throw new Error(this.record.state.error ?? 'Configuration requires retry or cancellation');
+        try {
+            if (this.recovering || this.record.state.operation !== undefined)
+                await this.reconcile();
+            while (!this.activeLease && this.record.state.pending !== undefined) {
+                this.change(record => {
+                    const pending = record.state.pending;
+                    record.state.operation = { ...pending, previous: structuredClone(record.state.current) };
+                    record.state.status = 'applying';
+                    record.requests[pending.requestId].receipt.status = 'applying';
+                });
+                const operation = structuredClone(this.record.state.operation);
+                const resolved = await this.adapter.apply(operation.selection, operation.previous, `${this.memberId}:${operation.revision}`);
+                this.change(record => { this.completeOperation(record, resolved); });
+            }
+        }
+        catch (error) {
+            this.recovering = true;
+            this.change(record => {
+                record.state.status = 'failed';
+                record.state.error = error instanceof Error ? error.message : String(error);
+                const requestId = record.state.pending?.requestId;
+                if (requestId !== undefined)
+                    record.requests[requestId].receipt.status = 'failed';
+            });
+            throw error;
+        }
+    }
+    /** The returned immutable lease belongs to one entire model/tool round. */
+    async admit(roundId) {
+        if (this.activeLease || this.admitting)
+            throw new Error('The member already has an active or admitting round');
+        this.admitting = true;
+        try {
+            for (;;) {
+                await this.work();
+                if (this.record.state.status === 'failed')
+                    throw new Error(this.record.state.error);
+                if (this.record.state.pending !== undefined)
+                    continue;
+                const revision = this.record.state.revision;
+                const resolved = await this.adapter.prepare?.(this.preparedSelection());
+                // A selection made during native preparation belongs before this
+                // admission, and must be confirmed before any prompt leaves core.
+                if (this.record.state.revision !== revision || this.record.state.pending !== undefined)
+                    continue;
+                if (resolved !== undefined) {
+                    this.assertFrozen(resolved);
+                    this.change(record => { record.state.current.resolved = resolved; });
+                }
+                if (this.record.state.lockedReason !== undefined && this.record.state.frozen === undefined) {
+                    this.change(record => { record.state.frozen = structuredClone(record.state.current); });
+                }
+                break;
+            }
+            const configuration = structuredClone(this.record.state.current);
+            this.change(record => { record.state.round = { id: roundId, configuration: structuredClone(configuration) }; });
+            Object.freeze(configuration.selection.model);
+            Object.freeze(configuration.selection.effort);
+            Object.freeze(configuration.selection);
+            Object.freeze(configuration.resolved);
+            Object.freeze(configuration);
+            this.activeLease = true;
+            let released = false;
+            return { configuration, release: () => {
+                    if (released)
+                        return;
+                    this.change(record => { delete record.state.round; });
+                    released = true;
+                    this.activeLease = false;
+                    this.kick();
+                } };
+        }
+        catch (error) {
+            this.rejectAdmission(error);
+            throw error;
+        }
+        finally {
+            this.admitting = false;
+            if (!this.activeLease)
+                this.kick();
+        }
+    }
+    async *follow(signal) {
+        let changed = true;
+        let wake;
+        const notify = () => { changed = true; wake?.(); wake = undefined; };
+        this.listeners.add(notify);
+        signal.addEventListener('abort', notify, { once: true });
+        try {
+            while (!signal.aborted) {
+                if (changed) {
+                    changed = false;
+                    yield this.read();
+                }
+                else
+                    await new Promise(resolve => { wake = resolve; });
+            }
+        }
+        finally {
+            this.listeners.delete(notify);
+            signal.removeEventListener('abort', notify);
+        }
+    }
+}

package/lib/types/member-controls.d.ts

@@ -0,0 +1,23 @@
+import type { SubagentRun } from '@deepseek-ai/dsh-subagent';
+import { MemberConfigurationController } from './member-control.ts';
+import type { MemberConfigurationAdapter, MemberControlStorage } from './member-control.ts';
+import type { LocalAgentAppliedConfiguration, LocalAgentMemberBinding } from './types.ts';
+/** The provider boundary owns the lease; facade and direct tool starts share it. */
+export declare class MemberControls {
+    private readonly storage;
+    private readonly adapter;
+    private readonly onError;
+    private readonly admitted;
+    configurationOf(run: object): LocalAgentAppliedConfiguration | undefined;
+    private readonly members;
+    constructor(storage: MemberControlStorage, adapter: (binding: LocalAgentMemberBinding) => MemberConfigurationAdapter, onError: (error: unknown) => void);
+    get(binding: LocalAgentMemberBinding): MemberConfigurationController;
+    binding(memberId: string): LocalAgentMemberBinding | undefined;
+    private readonly tails;
+    private readonly waiting;
+    queuedCount(memberId: string): number;
+    /** Every provider entry shares one FIFO through whole-round settlement. */
+    run(binding: LocalAgentMemberBinding, start: (configuration: LocalAgentAppliedConfiguration) => Promise<SubagentRun>, signal?: AbortSignal, onAdmitted?: () => void | Promise<void>): Promise<SubagentRun>;
+    private runNow;
+}
+//# sourceMappingURL=member-controls.d.ts.map

package/lib/types/member-controls.js

@@ -0,0 +1,143 @@
+import { randomUUID } from 'node:crypto';
+import { MemberConfigurationController } from './member-control.js';
+/** The provider boundary owns the lease; facade and direct tool starts share it. */
+export class MemberControls {
+    storage;
+    adapter;
+    onError;
+    admitted = new WeakMap();
+    configurationOf(run) {
+        const configuration = this.admitted.get(run);
+        return configuration === undefined ? undefined : structuredClone(configuration);
+    }
+    members = new Map();
+    constructor(storage, adapter, onError) {
+        this.storage = storage;
+        this.adapter = adapter;
+        this.onError = onError;
+    }
+    get(binding) {
+        const known = this.members.get(binding.childSessionId);
+        if (known !== undefined) {
+            for (const key of ['provider', 'parentSessionId', 'cwd', 'scope', 'model', 'effort', 'configurationLock']) {
+                if (known.binding[key] !== binding[key])
+                    throw new Error(`Member configuration identity changed: ${key}`);
+            }
+            return known.control;
+        }
+        // Resolve the currently mounted broker for every operation, including
+        // after a provider settings reload. Never retain a disposed driver.
+        const current = () => this.adapter(binding);
+        const control = new MemberConfigurationController(binding.childSessionId, this.storage, {
+            validate: selection => current().validate(selection),
+            apply: (selection, previous, operationId) => current().apply(selection, previous, operationId),
+            reconcile: state => current().reconcile(state),
+            prepare: async (selection) => {
+                const adapter = current();
+                await adapter.validate(selection);
+                if (adapter.prepare === undefined)
+                    throw new Error('Provider exposes no configuration admission preparation');
+                return adapter.prepare(selection);
+            },
+        }, {
+            selection: { model: { mode: 'inherit' }, effort: { mode: 'inherit' } },
+            ...binding.configurationLock === undefined ? {} : { lockedReason: binding.configurationLock },
+        });
+        this.members.set(binding.childSessionId, { binding: structuredClone(binding), control });
+        return control;
+    }
+    binding(memberId) {
+        const binding = this.members.get(memberId)?.binding;
+        return binding === undefined ? undefined : structuredClone(binding);
+    }
+    tails = new Map();
+    waiting = new Map();
+    queuedCount(memberId) { return this.waiting.get(memberId)?.size ?? 0; }
+    /** Every provider entry shares one FIFO through whole-round settlement. */
+    async run(binding, start, signal, onAdmitted) {
+        signal?.throwIfAborted();
+        this.get(binding); // Reject a foreign binding before accepting it into this member's queue.
+        const key = binding.childSessionId;
+        const previous = this.tails.get(key) ?? Promise.resolve();
+        const id = randomUUID();
+        const waiting = this.waiting.get(key) ?? new Set();
+        waiting.add(id);
+        this.waiting.set(key, waiting);
+        let queued = true;
+        let cancelled = false;
+        let resolve;
+        let reject;
+        const receipt = new Promise((yes, no) => { resolve = yes; reject = no; });
+        const remove = () => {
+            waiting.delete(id);
+            if (waiting.size === 0 && this.waiting.get(key) === waiting)
+                this.waiting.delete(key);
+        };
+        const abort = () => {
+            if (!queued)
+                return;
+            cancelled = true;
+            remove();
+            reject(signal?.reason ?? new Error('Queued member round cancelled'));
+        };
+        signal?.addEventListener('abort', abort, { once: true });
+        const task = previous.catch(() => { }).then(async () => {
+            queued = false;
+            signal?.removeEventListener('abort', abort);
+            remove();
+            if (cancelled)
+                return;
+            try {
+                signal?.throwIfAborted();
+                const run = await this.runNow(binding, start, signal, onAdmitted);
+                resolve(run);
+                await run.result;
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+        this.tails.set(key, task);
+        void task.finally(() => { if (this.tails.get(key) === task)
+            this.tails.delete(key); });
+        return receipt;
+    }
+    async runNow(binding, start, signal, onAdmitted) {
+        const control = this.get(binding);
+        const lease = await control.admit(randomUUID());
+        let nativeStarted = false;
+        try {
+            signal?.throwIfAborted();
+            await onAdmitted?.();
+            signal?.throwIfAborted();
+            nativeStarted = true;
+            const run = await start(lease.configuration);
+            this.admitted.set(run, lease.configuration);
+            const release = () => { try {
+                lease.release();
+            }
+            catch (error) {
+                this.onError(error);
+            } };
+            void run.result.then(release, release);
+            return run;
+        }
+        catch (error) {
+            // Cancelling a request is not a failed model/effort configuration.
+            if (nativeStarted && !signal?.aborted)
+                try {
+                    control.rejectAdmission(error);
+                }
+                catch (persistError) {
+                    this.onError(persistError);
+                }
+            try {
+                lease.release();
+            }
+            catch (releaseError) {
+                this.onError(releaseError);
+            }
+            throw error;
+        }
+    }
+}

package/lib/types/member-feed.d.ts

@@ -0,0 +1,4 @@
+import type { LocalAgentMemberFeedEvent, LocalAgentMemberFeedRequest } from './types.ts';
+/** One outstanding pull per source: slow clients do not accumulate event queues. */
+export declare function mergeMemberFeeds(requests: readonly LocalAgentMemberFeedRequest[], follow: (request: LocalAgentMemberFeedRequest, signal: AbortSignal) => AsyncIterable<LocalAgentMemberFeedEvent>, signal: AbortSignal): AsyncIterable<LocalAgentMemberFeedEvent>;
+//# sourceMappingURL=member-feed.d.ts.map

package/lib/types/member-feed.js

@@ -0,0 +1,45 @@
+/** One outstanding pull per source: slow clients do not accumulate event queues. */
+export async function* mergeMemberFeeds(requests, follow, signal) {
+    if (requests.length > 96)
+        throw new Error('Too many member feed channels');
+    const controller = new AbortController();
+    let stop;
+    const stopped = new Promise(resolve => { stop = () => { controller.abort(); resolve(undefined); }; });
+    signal.addEventListener('abort', stop, { once: true });
+    const iterators = [];
+    const pending = new Map();
+    const unique = new Map(requests.map(request => [JSON.stringify([request.memberId, request.channel]), request]));
+    try {
+        if (signal.aborted)
+            return;
+        for (const request of unique.values()) {
+            const source = (async function* () {
+                try {
+                    yield* follow(request, controller.signal);
+                }
+                catch (error) {
+                    if (!controller.signal.aborted)
+                        yield { memberId: request.memberId, channel: 'error', source: request.channel, message: error instanceof Error ? error.message : String(error) };
+                }
+            })()[Symbol.asyncIterator]();
+            const index = iterators.push(source) - 1;
+            pending.set(index, source.next().then(result => ({ index, result })));
+        }
+        while (!signal.aborted && pending.size > 0) {
+            const next = await Promise.race([...pending.values(), stopped]);
+            if (next === undefined)
+                return;
+            pending.delete(next.index);
+            if (next.result.done)
+                continue;
+            yield next.result.value;
+            pending.set(next.index, iterators[next.index].next().then(result => ({ index: next.index, result })));
+        }
+    }
+    finally {
+        signal.removeEventListener('abort', stop);
+        controller.abort();
+        for (const iterator of iterators)
+            void iterator.return?.().catch(() => { });
+    }
+}

package/lib/types/member-inbox.d.ts

@@ -0,0 +1,30 @@
+import type { SubagentRun } from '@deepseek-ai/dsh-subagent';
+import type { LocalAgentMemberInbox, LocalAgentMemberInput } from './types.ts';
+type Execute = (memberId: string, text: string, signal: AbortSignal, admitted: () => void) => Promise<SubagentRun>;
+/** Durable human input; the provider FIFO remains the sole execution order. */
+export declare class MemberInbox {
+    private readonly directory;
+    private readonly execute;
+    private readonly onError;
+    private readonly states;
+    private readonly active;
+    private readonly storageErrors;
+    private closed;
+    constructor(directory: string, execute: Execute, onError: (error: unknown) => void);
+    private path;
+    private load;
+    private save;
+    read(memberId: string): LocalAgentMemberInbox;
+    assertAdmission(memberId: string): void;
+    enqueue(memberId: string, text: string, requestId: string): LocalAgentMemberInput;
+    pause(memberId: string): void;
+    resume(memberId: string): void;
+    cancelStarting(memberId: string): boolean;
+    cancel(memberId: string, id: string): void;
+    reconcile(memberId: string, id: string, outcome: 'done' | 'cancelled', evidence: string): void;
+    private update;
+    private pump;
+    dispose(): void;
+}
+export {};
+//# sourceMappingURL=member-inbox.d.ts.map