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

package/lib/types/gateway.js

@@ -0,0 +1,470 @@
+/**
+ * Read-only Remote channel for the local-agent family: roster, per-harness
+ * auth status, and scoped session records. The web client polls these through
+ * Typert Gateway instead of the slash-command channel, so UI refreshes never
+ * leave `command/run`/`command/done` lifecycle nodes in the session log.
+ * Sign-out and login stay on the command channel: they are user-initiated
+ * actions whose visible command node is the expected feedback.
+ * @module @khorsheed/dsh-local-agent/gateway
+ */
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { randomUUID } from 'node:crypto';
+import { SessionId } from '@deepseek-ai/dsh-session';
+import { TypertRemoteService, Remote } from '@deepseek-ai/dsh-typert-protocol';
+import { extendModelDirectory } from './model-directory.js';
+import { mergeMemberFeeds } from './member-feed.js';
+/**
+ * Remote-only projection of the local-agent registry, exposed to the browser
+ * through Typert Gateway under the `localAgentGateway` service key.
+ */
+/**
+ * Fold a model surface's `lastObserved` into its pick list: a member (or
+ * harness) whose only named model is what it was observed running still gets
+ * a one-item menu instead of an empty one. The observation appends LAST —
+ * the broker's own choices keep their ranking — and an already-listed value
+ * leaves the list untouched (choices arrive deduped from the broker).
+ */
+function withObservedChoice(info) {
+    const observed = info.lastObserved;
+    if (observed === undefined)
+        return info;
+    return {
+        ...info,
+        choices: info.choices.includes(observed) ? info.choices : [...info.choices, observed],
+        ...info.directory === undefined ? {} : { directory: extendModelDirectory(info.directory, [], [observed]) },
+    };
+}
+let LocalAgentGateway = (() => {
+    let _classSuper = TypertRemoteService;
+    let _instanceExtraInitializers = [];
+    let _followMemberOutput_decorators;
+    let _followMembers_decorators;
+    let _modelDirectory_decorators;
+    let _followModelDirectory_decorators;
+    let _memberDirectory_decorators;
+    let _followMemberDirectory_decorators;
+    let _roster_decorators;
+    let _activeDelegations_decorators;
+    let _status_decorators;
+    let _sessions_decorators;
+    let _memberOf_decorators;
+    let _harnessModel_decorators;
+    let _memberModel_decorators;
+    let _setMemberModel_decorators;
+    let _memberConfiguration_decorators;
+    let _selectMemberConfiguration_decorators;
+    let _cancelMemberConfiguration_decorators;
+    let _retryMemberConfiguration_decorators;
+    let _followMemberConfiguration_decorators;
+    let _promptMember_decorators;
+    let _memberInbox_decorators;
+    let _controlMemberInbox_decorators;
+    let _stopMember_decorators;
+    return class LocalAgentGateway extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _followMemberOutput_decorators = [Remote({ mode: 'stream' })];
+            _followMembers_decorators = [Remote({ mode: 'stream' })];
+            _modelDirectory_decorators = [Remote('modelDirectory')];
+            _followModelDirectory_decorators = [Remote({ mode: 'stream' })];
+            _memberDirectory_decorators = [Remote('memberDirectory')];
+            _followMemberDirectory_decorators = [Remote({ mode: 'stream' })];
+            _roster_decorators = [Remote('roster')];
+            _activeDelegations_decorators = [Remote('activeDelegations')];
+            _status_decorators = [Remote('status')];
+            _sessions_decorators = [Remote('sessions')];
+            _memberOf_decorators = [Remote('memberOf')];
+            _harnessModel_decorators = [Remote('harnessModel')];
+            _memberModel_decorators = [Remote('memberModel')];
+            _setMemberModel_decorators = [Remote('setMemberModel')];
+            _memberConfiguration_decorators = [Remote('memberConfiguration')];
+            _selectMemberConfiguration_decorators = [Remote('selectMemberConfiguration')];
+            _cancelMemberConfiguration_decorators = [Remote('cancelMemberConfiguration')];
+            _retryMemberConfiguration_decorators = [Remote('retryMemberConfiguration')];
+            _followMemberConfiguration_decorators = [Remote({ mode: 'stream' })];
+            _promptMember_decorators = [Remote('promptMember')];
+            _memberInbox_decorators = [Remote('memberInbox')];
+            _controlMemberInbox_decorators = [Remote('controlMemberInbox')];
+            _stopMember_decorators = [Remote('stopMember')];
+            __esDecorate(this, null, _followMemberOutput_decorators, { kind: "method", name: "followMemberOutput", static: false, private: false, access: { has: obj => "followMemberOutput" in obj, get: obj => obj.followMemberOutput }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _followMembers_decorators, { kind: "method", name: "followMembers", static: false, private: false, access: { has: obj => "followMembers" in obj, get: obj => obj.followMembers }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _modelDirectory_decorators, { kind: "method", name: "modelDirectory", static: false, private: false, access: { has: obj => "modelDirectory" in obj, get: obj => obj.modelDirectory }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _followModelDirectory_decorators, { kind: "method", name: "followModelDirectory", static: false, private: false, access: { has: obj => "followModelDirectory" in obj, get: obj => obj.followModelDirectory }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _memberDirectory_decorators, { kind: "method", name: "memberDirectory", static: false, private: false, access: { has: obj => "memberDirectory" in obj, get: obj => obj.memberDirectory }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _followMemberDirectory_decorators, { kind: "method", name: "followMemberDirectory", static: false, private: false, access: { has: obj => "followMemberDirectory" in obj, get: obj => obj.followMemberDirectory }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _roster_decorators, { kind: "method", name: "roster", static: false, private: false, access: { has: obj => "roster" in obj, get: obj => obj.roster }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _activeDelegations_decorators, { kind: "method", name: "activeDelegations", static: false, private: false, access: { has: obj => "activeDelegations" in obj, get: obj => obj.activeDelegations }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _status_decorators, { kind: "method", name: "status", static: false, private: false, access: { has: obj => "status" in obj, get: obj => obj.status }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _sessions_decorators, { kind: "method", name: "sessions", static: false, private: false, access: { has: obj => "sessions" in obj, get: obj => obj.sessions }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _memberOf_decorators, { kind: "method", name: "memberOf", static: false, private: false, access: { has: obj => "memberOf" in obj, get: obj => obj.memberOf }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _harnessModel_decorators, { kind: "method", name: "harnessModel", static: false, private: false, access: { has: obj => "harnessModel" in obj, get: obj => obj.harnessModel }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _memberModel_decorators, { kind: "method", name: "memberModel", static: false, private: false, access: { has: obj => "memberModel" in obj, get: obj => obj.memberModel }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _setMemberModel_decorators, { kind: "method", name: "setMemberModel", static: false, private: false, access: { has: obj => "setMemberModel" in obj, get: obj => obj.setMemberModel }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _memberConfiguration_decorators, { kind: "method", name: "memberConfiguration", static: false, private: false, access: { has: obj => "memberConfiguration" in obj, get: obj => obj.memberConfiguration }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _selectMemberConfiguration_decorators, { kind: "method", name: "selectMemberConfiguration", static: false, private: false, access: { has: obj => "selectMemberConfiguration" in obj, get: obj => obj.selectMemberConfiguration }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _cancelMemberConfiguration_decorators, { kind: "method", name: "cancelMemberConfiguration", static: false, private: false, access: { has: obj => "cancelMemberConfiguration" in obj, get: obj => obj.cancelMemberConfiguration }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _retryMemberConfiguration_decorators, { kind: "method", name: "retryMemberConfiguration", static: false, private: false, access: { has: obj => "retryMemberConfiguration" in obj, get: obj => obj.retryMemberConfiguration }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _followMemberConfiguration_decorators, { kind: "method", name: "followMemberConfiguration", static: false, private: false, access: { has: obj => "followMemberConfiguration" in obj, get: obj => obj.followMemberConfiguration }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _promptMember_decorators, { kind: "method", name: "promptMember", static: false, private: false, access: { has: obj => "promptMember" in obj, get: obj => obj.promptMember }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _memberInbox_decorators, { kind: "method", name: "memberInbox", static: false, private: false, access: { has: obj => "memberInbox" in obj, get: obj => obj.memberInbox }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _controlMemberInbox_decorators, { kind: "method", name: "controlMemberInbox", static: false, private: false, access: { has: obj => "controlMemberInbox" in obj, get: obj => obj.controlMemberInbox }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _stopMember_decorators, { kind: "method", name: "stopMember", static: false, private: false, access: { has: obj => "stopMember" in obj, get: obj => obj.stopMember }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static inject = ['localAgent', 'sessions'];
+        constructor(ctx) {
+            super(ctx, 'localAgentGateway');
+            __runInitializers(this, _instanceExtraInitializers);
+        }
+        /**
+         * Follow one member's transient output with a complete reconnect baseline.
+         * @param childSessionId - mirrored session identity.
+         * @param signal - Remote-owned cancellation, including browser disconnects.
+         * @returns bounded incremental updates; final content remains in session history.
+         */
+        followMemberOutput(childSessionId, signal) {
+            return this.ctx.localAgent.liveStreams.follow(childSessionId, signal);
+        }
+        /** Shared browser stream: adding visible members does not consume more HTTP connections. */
+        followMembers(requests, signal) {
+            return mergeMemberFeeds(requests, (request, signal) => this.memberFeed(request, signal), signal);
+        }
+        async *memberFeed(request, signal) {
+            const memberId = request.memberId;
+            switch (request.channel) {
+                case 'output':
+                    for await (const value of this.followMemberOutput(memberId, signal))
+                        yield { memberId, channel: 'output', value };
+                    break;
+                case 'configuration':
+                    for await (const value of this.followMemberConfiguration(memberId, signal))
+                        yield { memberId, channel: 'configuration', value };
+                    break;
+                case 'directory':
+                    for await (const value of this.followMemberDirectory(memberId, signal))
+                        yield { memberId, channel: 'directory', value };
+                    break;
+            }
+        }
+        directoryBroker(name, childSessionId) {
+            const harness = this.ctx.localAgent.get(name);
+            if (childSessionId !== undefined) {
+                const record = this.ctx.localAgent.getDelegation(childSessionId);
+                if (record === undefined || record.provider !== harness?.delegationProvider)
+                    return undefined;
+            }
+            return harness?.modelBroker;
+        }
+        /**
+         * Read or explicitly refresh native model discovery, without changing a member.
+         * @param name - owning harness.
+         * @param childSessionId - member context, or undefined for the harness default.
+         * @param refresh - bypass the discovery TTL.
+         * @returns source-labelled discovery state, or null for an unavailable broker.
+         */
+        async modelDirectory(name, childSessionId, refresh) {
+            const broker = this.directoryBroker(name, childSessionId);
+            return await broker?.modelDirectory?.(childSessionId, refresh) ?? null;
+        }
+        /**
+         * Keep a currently open model picker synchronized with discovery completion.
+         * @param name - owning harness.
+         * @param childSessionId - member context, or undefined for the harness default.
+         * @param signal - Remote-owned cancellation.
+         * @returns directory baselines and subsequent snapshots.
+         */
+        async *followModelDirectory(name, childSessionId, signal) {
+            const broker = this.directoryBroker(name, childSessionId);
+            if (broker?.followModelDirectory !== undefined)
+                yield* broker.followModelDirectory(childSessionId, signal);
+            else {
+                const directory = await broker?.modelDirectory?.(childSessionId);
+                if (directory !== undefined && !signal.aborted)
+                    yield directory;
+            }
+        }
+        /** Resolve directory ownership from the recorded member, never a UI provider guess. */
+        async memberDirectory(childSessionId, refresh) {
+            const record = this.ctx.localAgent.getDelegation(childSessionId) ?? this.ctx.localAgent.memberBinding?.(childSessionId);
+            const broker = record === undefined ? undefined : this.ctx.localAgent.harnessForProvider(record.provider)?.modelBroker;
+            return await broker?.modelDirectory?.(childSessionId, refresh) ?? null;
+        }
+        async *followMemberDirectory(childSessionId, signal) {
+            const record = this.ctx.localAgent.getDelegation(childSessionId) ?? this.ctx.localAgent.memberBinding?.(childSessionId);
+            const broker = record === undefined ? undefined : this.ctx.localAgent.harnessForProvider(record.provider)?.modelBroker;
+            if (broker?.followModelDirectory !== undefined)
+                yield* broker.followModelDirectory(childSessionId, signal);
+            else {
+                const directory = await broker?.modelDirectory?.(childSessionId);
+                if (directory !== undefined && !signal.aborted)
+                    yield directory;
+            }
+        }
+        /**
+         * Registered harnesses in registration order.
+         * @returns the roster rows.
+         */
+        roster() {
+            return this.ctx.localAgent.roster();
+        }
+        /**
+         * The child session ids with an in-flight delegation run (the
+         * active-delegation registry's key set). Surfaces that render one-shot
+         * subagent rows poll this to mark a row as actually running — the official
+         * session summary's `running` flag is agent-based and stays false for
+         * external CLI one-shots, which have no live agent — and to offer the
+         * stop verb that dispatches `/local-agent stop <childSessionId>`.
+         * @returns the in-flight child session ids.
+         */
+        activeDelegations() {
+            return this.ctx.localAgent.activeDelegations();
+        }
+        /**
+         * One harness's auth status, in the default scope or in a named one.
+         * @param name - the harness name.
+         * @param scope - the named scope to report on; absent means the default
+         *   scope, so a client written before scopes existed gets exactly the
+         *   snapshot it always got.
+         * @returns the status snapshot.
+         */
+        status(name, scope) {
+            return this.ctx.localAgent.statusOf(name, scope);
+        }
+        /**
+         * One harness's scoped session records, optionally narrowed to the sessions
+         * whose working directory is a given dsh session's cwd — the delegations a
+         * session's workspace actually produced, so one project's kimi sessions do
+         * not surface in another project's session.
+         * @param name - the harness name.
+         * @param sessionId - optional dsh session whose cwd filters the records.
+         * @returns the matching session records.
+         */
+        async sessions(name, sessionId) {
+            const records = await this.ctx.localAgent.sessionsOf(name);
+            if (sessionId === undefined)
+                return records;
+            const cwd = this.ctx.sessions.get(SessionId(sessionId))?.header.cwd;
+            if (cwd === undefined)
+                return records;
+            return records.filter(record => record.workDir === cwd);
+        }
+        /**
+         * The member channel's membership check: the delegation view for one dsh
+         * child session, or null when the family never delegated it. The composer
+         * chain elects on the session snapshot alone (one-shot subagent), then
+         * confirms membership through this Remote — a null answer renders the same
+         * read-only panel the official composer shows, never a writable box.
+         * The CLI-session resume handle (`cliSessionId`) deliberately stays off the
+         * wire: the resume facade resolves it host-side from the record.
+         * @param childSessionId - the dsh child session id being viewed.
+         * @returns the delegation view, or null for a non-member session.
+         */
+        memberOf(childSessionId) {
+            const registry = this.ctx.localAgent;
+            const record = registry.getDelegation(childSessionId);
+            if (record === undefined)
+                return null;
+            const harness = registry.harnessForProvider(record.provider);
+            return {
+                childSessionId: record.childSessionId,
+                provider: record.provider,
+                parentSessionId: record.parentSessionId,
+                ...harness === undefined ? {} : { harnessDisplayName: harness.displayName },
+            };
+        }
+        /**
+         * The model surface of one harness without a member — the settings card's
+         * "what would a round run with" read. Null when the harness is unknown or
+         * exposes no model broker: the card then keeps its free-text field exactly
+         * as before brokers existed. The core fills `lastObserved` from the
+         * delegation records (the harness's own provider) when the broker's answer
+         * carries none — display context for the cli-builtin layer, never a layer —
+         * and appends it to `choices` when no broker choice lists it, so the card's
+         * menu offers what last ran instead of staying empty.
+         * @param name - the harness name.
+         * @returns the layer-by-layer surface, or null.
+         */
+        async harnessModel(name) {
+            const harness = this.ctx.localAgent.get(name);
+            if (harness?.modelBroker === undefined)
+                return null;
+            const info = await harness.modelBroker.modelInfo();
+            // A harness without a delegation provider has no records to observe from.
+            const observed = harness.delegationProvider === undefined
+                ? undefined
+                : this.ctx.localAgent.latestObservedModel(harness.delegationProvider);
+            return withObservedChoice(info.lastObserved !== undefined || observed === undefined
+                ? info
+                : { ...info, lastObserved: observed });
+        }
+        /**
+         * The model surface of one member — the composer's picker read. The
+         * delegation record's requested model rides in from the core so the broker
+         * can rank it between the override and the settings layer; the record's
+         * OBSERVED model fills `lastObserved` when the broker's answer carries none
+         * (a broker that names one itself always wins — spread order: the broker's
+         * answer first, the core's fill only over an absent field) and joins
+         * `choices` as the last entry when no broker choice lists it, so a member
+         * that ran once has a one-item pick list instead of an empty menu. Null for a
+         * non-member session or a brokerless harness.
+         * @param childSessionId - the dsh child session id of the member.
+         * @returns the layer-by-layer surface, or null.
+         */
+        async memberModel(childSessionId) {
+            const registry = this.ctx.localAgent;
+            const observed = registry.getDelegation(childSessionId);
+            const record = observed ?? registry.memberBinding?.(childSessionId);
+            if (record === undefined)
+                return null;
+            const broker = registry.harnessForProvider(record.provider)?.modelBroker;
+            if (broker === undefined)
+                return null;
+            let info = await broker.modelInfo(childSessionId, record.model);
+            if (broker.configurationAdapter !== undefined) {
+                const configuration = registry.memberConfiguration(childSessionId);
+                info = { ...info, configuration, switchable: configuration.lockedReason === undefined };
+                delete info.reason;
+                if (configuration.lockedReason !== undefined)
+                    info.reason = configuration.lockedReason;
+                if (configuration.current.resolved.model !== undefined)
+                    info.effective = configuration.current.resolved.model;
+            }
+            return withObservedChoice(info.lastObserved !== undefined || observed?.observedModel === undefined
+                ? info
+                : { ...info, lastObserved: observed?.observedModel });
+        }
+        /**
+         * Switch a member's session-level model (the composer's picker write). The
+         * override outranks the delegation's recorded model and the settings
+         * layer; with the live driver on it retires the member's resident runtime
+         * so the NEXT round respawns onto the new model — the CLI session itself
+         * (its rollout) carries over. Failures arrive structured, never raw.
+         * @param childSessionId - the dsh child session id of the member.
+         * @param model - the model identifier, or undefined to clear the override
+         *   (the member then follows the settings layer again).
+         * @returns `{ ok: true }` once applied, or a structured error.
+         */
+        async setMemberModel(childSessionId, model) {
+            const registry = this.ctx.localAgent;
+            const record = registry.getDelegation(childSessionId);
+            if (record === undefined) {
+                return { ok: false, error: `localAgent: no delegation recorded for child session ${childSessionId}` };
+            }
+            const broker = registry.harnessForProvider(record.provider)?.modelBroker;
+            if (broker === undefined) {
+                return { ok: false, error: `localAgent: ${record.provider} exposes no model broker` };
+            }
+            try {
+                if (broker.configurationAdapter === undefined)
+                    await broker.setMemberModel(childSessionId, model);
+                else
+                    await registry.setMemberModel(childSessionId, model);
+            }
+            catch (error) {
+                return { ok: false, error: error instanceof Error ? error.message : String(error) };
+            }
+            return { ok: true };
+        }
+        async memberConfiguration(childSessionId) {
+            return this.ctx.localAgent.memberConfiguration(childSessionId);
+        }
+        async selectMemberConfiguration(childSessionId, requestId, expectedRevision, selection) {
+            return this.ctx.localAgent.selectMemberConfiguration(childSessionId, requestId, expectedRevision, selection);
+        }
+        async cancelMemberConfiguration(childSessionId, requestId, expectedRevision) {
+            return this.ctx.localAgent.cancelMemberConfiguration(childSessionId, requestId, expectedRevision);
+        }
+        async retryMemberConfiguration(childSessionId, expectedRevision) {
+            await this.ctx.localAgent.retryMemberConfiguration(childSessionId, expectedRevision);
+        }
+        followMemberConfiguration(childSessionId, signal) {
+            return this.ctx.localAgent.followMemberConfiguration(childSessionId, signal);
+        }
+        /**
+         * Send one human-authored follow-up to a family member: continue the
+         * member's SAME CLI session inside the SAME dsh child session. The child
+         * session id is the membership proof — the user opened the real child
+         * session, and the recorded delegation is the authorization source — so
+         * there is no model-forged handle surface; the resume handle never enters
+         * the prompt text. The prompt goes through the facade
+         * ({@link LocalAgentRegistry.resume}) unchanged: ownership check, resume
+         * lock, reattach, and run tracking all apply.
+         * @param childSessionId - the dsh child session id of the member.
+         * @param text - the human's follow-up message.
+         * @returns `{ ok: true }` once the run started, or a structured error
+         *   (unknown member, parent not live, resume in flight) for the composer to
+         *   render inline — raw exceptions never cross the wire.
+         */
+        async promptMember(childSessionId, text, requestId) {
+            try {
+                return { ok: true, requestId: this.ctx.localAgent.enqueueMemberInput(childSessionId, text, requestId ?? randomUUID()) };
+            }
+            catch (error) {
+                return { ok: false, error: String(error) };
+            }
+        }
+        memberInbox(childSessionId) { return this.ctx.localAgent.readMemberInbox(childSessionId); }
+        controlMemberInbox(childSessionId, action, requestId, outcome, evidence) {
+            try {
+                this.ctx.localAgent.readMemberInbox(childSessionId);
+                const inbox = this.ctx.localAgent.memberInbox;
+                if (action === 'pause')
+                    inbox.pause(childSessionId);
+                else if (action === 'resume')
+                    this.ctx.localAgent.resumeMemberInbox(childSessionId);
+                else if (action === 'cancel' && requestId !== undefined)
+                    inbox.cancel(childSessionId, requestId);
+                else if (action === 'reconcile' && requestId !== undefined && outcome !== undefined && evidence !== undefined)
+                    inbox.reconcile(childSessionId, requestId, outcome, evidence);
+                else
+                    throw new Error('Invalid member inbox control');
+                return { ok: true };
+            }
+            catch (error) {
+                return { ok: false, error: String(error) };
+            }
+        }
+        /**
+         * Interrupt a member's in-flight run (the composer's Stop).
+         * @param childSessionId - the dsh child session id of the member.
+         * @returns whether an in-flight run was found and signalled.
+         */
+        stopMember(childSessionId) {
+            return this.ctx.localAgent.cancel(childSessionId);
+        }
+    };
+})();
+export default LocalAgentGateway;