newmark-agent 0.5.14 → 0.6.0

package/dist/core/subagent.js

@@ -1,10 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SubagentManager = void 0;
+exports.SubagentManager = exports.SUBAGENT_RECOVERY_PROMPT = void 0;
 exports.sharedSubagentManager = sharedSubagentManager;
 exports.releaseSharedSubagentManager = releaseSharedSubagentManager;
 const crypto_1 = require("crypto");
+exports.SUBAGENT_RECOVERY_PROMPT = '[Peer runtime recovery] Continue the unfinished work from the persisted working history. Preserve completed tool results and follow the latest instruction; do not repeat completed work.';
 function now() { return new Date().toISOString(); }
+function cloneMailboxMessage(message) {
+    return { ...message, ...(message.control ? { control: { ...message.control } } : {}) };
+}
 function natureSlug(value) {
     const normalized = String(value || 'subagent')
         .normalize('NFKD')
@@ -15,7 +19,14 @@ function natureSlug(value) {
     return normalized || 'subagent';
 }
 function cloneRecord(record) {
-    return { ...record, messages: record.messages.map(message => ({ ...message })), metadata: record.metadata ? { ...record.metadata } : undefined };
+    return {
+        ...record,
+        messages: record.messages.map(message => ({
+            ...message,
+            tool_calls: message.tool_calls?.map(call => ({ ...call, function: { ...call.function } })),
+        })),
+        metadata: record.metadata ? structuredClone(record.metadata) : undefined,
+    };
 }
 function truncateText(value, maxChars) {
     const text = String(value || '');
@@ -33,6 +44,7 @@ class SubagentManager {
     rootInbox = [];
     pending = [];
     running = new Set();
+    activeJobs = new Map();
     schedulingPaused = false;
     nextSequence = 1;
     concurrency;
@@ -41,18 +53,25 @@ class SubagentManager {
     persist;
     onMailboxMessage;
     rootInboxListeners = new Set();
+    bindingOwner;
+    ownerBindings = new Map();
     onSettled;
     changedQueued = false;
     settledWaiters = new Map();
     conversationId;
     rootAgentId;
     hasRecords() { return this.subs.size > 0 || this.mailbox.length > 0 || this.rootInbox.length > 0; }
+    hasPendingWork() {
+        return this.running.size > 0 || this.pending.length > 0
+            || Array.from(this.subs.values()).some(record => record.status === 'queued' || record.status === 'working');
+    }
     reset() {
         this.subs.clear();
         this.mailbox = [];
         this.rootInbox = [];
         this.pending = [];
         this.running.clear();
+        this.activeJobs.clear();
         this.settledWaiters.clear();
         this.nextSequence = 1;
         this.schedulingPaused = false;
@@ -64,13 +83,17 @@ class SubagentManager {
         this.onChange = options.onChange;
         this.persist = options.persist;
         this.onMailboxMessage = options.onMailboxMessage;
-        if (options.onRootInboxMessage)
+        if (options.onRootInboxMessage) {
             this.rootInboxListeners.add(options.onRootInboxMessage);
+            this.bindingOwner = options.onRootInboxMessage;
+        }
         this.onSettled = options.onSettled;
+        this.rememberOwnerBinding();
         const state = options.state;
         this.rootAgentId = String(state?.rootAgentId || options.rootAgentId || (0, crypto_1.randomUUID)());
         this.nextSequence = Math.max(1, Number(state?.nextSequence || 1));
         this.schedulingPaused = state?.schedulingPaused === true;
+        const savedJobs = new Map((state?.jobs || []).map(job => [job.id, job]));
         for (const raw of state?.records || []) {
             const record = cloneRecord(raw);
             record.messages = record.messages.map(message => message.role === 'user'
@@ -80,13 +103,24 @@ class SubagentManager {
                 record.status = 'queued';
             this.subs.set(record.id, record);
             if (record.status === 'queued') {
-                const sequence = Number(record.queueSequence || this.nextSequence++);
+                const savedJob = savedJobs.get(record.id);
+                const sequence = Number(savedJob?.sequence || record.queueSequence || this.nextSequence++);
+                this.nextSequence = Math.max(this.nextSequence, sequence + 1);
                 record.queueSequence = sequence;
-                this.pending.push({ id: record.id, prompt: record.messages.filter(message => message.role === 'user').at(-1)?.content || record.prompt, flowName: record.flowName || '', sequence, reason: 'resume' });
+                this.pending.push(savedJob
+                    ? { ...savedJob, sequence }
+                    : { id: record.id, prompt: record.messages.filter(message => message.role === 'user').at(-1)?.content || record.prompt, flowName: record.flowName || '', sequence, reason: 'resume' });
             }
         }
-        this.mailbox = (state?.mailbox || []).map(message => ({ ...message }));
-        this.rootInbox = (state?.rootInbox || []).map(message => ({ ...message }));
+        // Historical messages always woke their recipient. Migrate only an absent
+        // field; an explicitly stored false must remain passive after a restart.
+        this.mailbox = (state?.mailbox || []).map(message => ({ ...cloneMailboxMessage(message),
+            wakeup: message.wakeup === undefined ? true : message.wakeup === true,
+            acceptedWhileActive: message.acceptedWhileActive === true,
+        }));
+        this.rootInbox = (state?.rootInbox || []).map(message => ({ ...message,
+            wakeup: message.wakeup === undefined ? true : message.wakeup === true,
+        }));
         for (const record of this.subs.values())
             this.queuePersistedUnread(record);
         this.pending.sort((a, b) => a.sequence - b.sequence);
@@ -95,28 +129,79 @@ class SubagentManager {
     bind(options) {
         if (options.concurrency !== undefined)
             this.setConcurrencyLimit(options.concurrency);
-        if (options.executor)
-            this.executor = options.executor;
-        if (options.onChange)
-            this.onChange = options.onChange;
-        if (options.persist)
-            this.persist = options.persist;
-        if (options.onMailboxMessage)
-            this.onMailboxMessage = options.onMailboxMessage;
         if (options.onRootInboxMessage) {
             const listener = options.onRootInboxMessage;
+            const previous = this.ownerBindings.get(listener);
+            const binding = {
+                executor: options.executor || previous?.executor,
+                onChange: options.onChange || previous?.onChange,
+                persist: options.persist || previous?.persist,
+                onMailboxMessage: options.onMailboxMessage || previous?.onMailboxMessage,
+                onSettled: options.onSettled || previous?.onSettled,
+            };
+            this.ownerBindings.delete(listener);
+            this.ownerBindings.set(listener, binding);
+            // A snapshot/foreground facade must not steal jobs or their settlement
+            // callbacks from the owner that is currently executing the queue.
+            if (!this.bindingOwner || this.bindingOwner === listener || !this.hasPendingWork()) {
+                this.bindingOwner = listener;
+                Object.assign(this, binding);
+            }
             const added = !this.rootInboxListeners.has(listener);
             this.rootInboxListeners.add(listener);
             if (added)
                 queueMicrotask(() => this.replayRootInbox(listener));
         }
-        if (options.onSettled)
-            this.onSettled = options.onSettled;
+        else {
+            if (options.executor)
+                this.executor = options.executor;
+            if (options.onChange)
+                this.onChange = options.onChange;
+            if (options.persist)
+                this.persist = options.persist;
+            if (options.onMailboxMessage)
+                this.onMailboxMessage = options.onMailboxMessage;
+            if (options.onSettled)
+                this.onSettled = options.onSettled;
+            this.rememberOwnerBinding();
+        }
         this.pump();
     }
+    ownsExecutionBinding(listener) {
+        return this.bindingOwner === listener;
+    }
+    rememberOwnerBinding() {
+        if (!this.bindingOwner)
+            return;
+        this.ownerBindings.delete(this.bindingOwner);
+        this.ownerBindings.set(this.bindingOwner, {
+            executor: this.executor, onChange: this.onChange, persist: this.persist,
+            onMailboxMessage: this.onMailboxMessage, onSettled: this.onSettled,
+        });
+    }
     removeRootInboxListener(listener) {
         this.rootInboxListeners.delete(listener);
     }
+    /** Detach one facade without clearing a newer owner's callbacks or live jobs. */
+    releaseOwnerBinding(listener) {
+        if (this.bindingOwner === listener && this.hasPendingWork())
+            return false;
+        this.rootInboxListeners.delete(listener);
+        this.ownerBindings.delete(listener);
+        if (this.bindingOwner !== listener)
+            return true;
+        // A temporary facade may have rebound this shared manager while another
+        // idle facade remained usable. Restore that owner instead of stranding
+        // its next peer in the durable queue with no executor.
+        const previous = Array.from(this.ownerBindings.entries()).at(-1);
+        this.bindingOwner = previous?.[0];
+        this.executor = previous?.[1].executor;
+        this.onChange = previous?.[1].onChange;
+        this.persist = previous?.[1].persist;
+        this.onMailboxMessage = previous?.[1].onMailboxMessage;
+        this.onSettled = previous?.[1].onSettled;
+        return true;
+    }
     create(name, prompt, model, inputMode, agentMode = 'build', createdByAgentId = this.rootAgentId, flowName = '', goalObjective = '', flowPc = 0, buildRunId = '', intelligenceTier = '') {
         const id = (0, crypto_1.randomUUID)();
         const shortId = id.replace(/-/g, '').slice(0, 8);
@@ -169,18 +254,44 @@ class SubagentManager {
         // convenience lookup only; the id/shortId/displayName paths stay exact.
         return [...this.subs.values()].find(item => item.name === id || item.displayName === id || item.shortId === id || item.natureSlug === natureSlug(id));
     }
-    send(id, prompt) {
-        const target = this.get(id);
-        if (!target || target.status === 'closed')
-            return false;
-        target.messages.push({ role: 'user', content: prompt, hidden_user_input: true });
-        target.error = undefined;
-        target.completedAt = undefined;
-        target.updatedAt = now();
-        this.enqueue(target, prompt, target.flowName || '', 'mailbox');
-        return true;
+    send(id, prompt, wakeup = false) {
+        // The compatibility entry point shares the durable mailbox and its
+        // single-executor guarantee; a direct enqueue could overlap this peer.
+        return this.sendMessage(this.rootAgentId, id, prompt, 'directive', {}, wakeup).ok;
+    }
+    broadcastStop(fromAgentId, runId, force = false) {
+        // Set the gate before publishing any control receipt, and commit the gate
+        // plus the entire batch once. No per-message callback can dispatch work.
+        const wasPaused = this.schedulingPaused;
+        this.schedulingPaused = true;
+        const ids = [];
+        const peerIds = [];
+        const stamp = now();
+        const stopRunId = String(runId || '');
+        const alreadySent = new Set(this.mailbox.filter(message => message.control?.action === 'stop'
+            && message.control.runId === stopRunId && message.control.force === (force === true)).map(message => message.toAgentId));
+        for (const record of this.subs.values()) {
+            if (record.status === 'closed' || alreadySent.has(record.id))
+                continue;
+            const message = {
+                id: (0, crypto_1.randomUUID)(), conversationId: this.conversationId, sequence: this.nextSequence++,
+                fromAgentId, toAgentId: record.id, kind: 'directive',
+                body: force ? '[Runtime control] Force stop this conversation work.' : '[Runtime control] Stop this conversation work.',
+                wakeup: false, acceptedWhileActive: false,
+                control: { action: 'stop', runId: stopRunId, force: force === true },
+                createdAt: stamp, readAt: stamp,
+            };
+            this.mailbox.push(message);
+            ids.push(message.id);
+            peerIds.push(record.id);
+        }
+        if (!wasPaused || ids.length) {
+            this.persistNow();
+            this.changed();
+        }
+        return { count: ids.length, ids, peerIds };
     }
-    sendMessage(fromAgentId, toAgentId, body, kind = 'directive', details = {}) {
+    sendMessage(fromAgentId, toAgentId, body, kind = 'directive', details = {}, wakeup = false) {
         if (!body.trim())
             return { ok: false, error: 'Message body is required.' };
         if (fromAgentId === toAgentId)
@@ -188,6 +299,8 @@ class SubagentManager {
         const target = this.get(toAgentId);
         if (!target)
             return { ok: false, error: `Peer agent not found: ${toAgentId}` };
+        if (fromAgentId === target.id)
+            return { ok: false, error: 'Peer agents cannot message themselves.' };
         if (target.status === 'closed')
             return { ok: false, error: `Peer agent is closed: ${target.qualifiedName}` };
         const message = {
@@ -198,6 +311,8 @@ class SubagentManager {
             toAgentId: target.id,
             kind,
             body: truncateText(body, 32000),
+            wakeup: wakeup === true,
+            acceptedWhileActive: target.status === 'working' || target.status === 'queued',
             correlationId: details.correlationId,
             replyTo: details.replyTo,
             createdAt: now(),
@@ -213,7 +328,7 @@ class SubagentManager {
         this.changed();
         return { ok: true, message: { ...message } };
     }
-    sendRootMessage(fromAgentId, body, kind = 'result') {
+    sendRootMessage(fromAgentId, body, kind = 'result', settlementRevision, wakeup = false) {
         if (!body.trim())
             return { ok: false, error: 'Message body is required.' };
         if (fromAgentId === this.rootAgentId)
@@ -226,7 +341,11 @@ class SubagentManager {
             toAgentId: this.rootAgentId,
             kind,
             body: truncateText(body, 32000),
+            wakeup: wakeup === true,
             createdAt: now(),
+            ...(kind === 'result' && Number.isSafeInteger(settlementRevision) && Number(settlementRevision) > 0
+                ? { source: 'automatic-settlement', settlementRevision }
+                : {}),
         };
         this.rootInbox.push(message);
         this.persistNow();
@@ -240,6 +359,31 @@ class SubagentManager {
             .sort((a, b) => a.sequence - b.sequence)
             .map(message => ({ ...message }));
     }
+    acknowledgeSettlementResults(receipts) {
+        const observed = new Set(receipts.filter(receipt => typeof receipt.peerId === 'string'
+            && Number.isSafeInteger(receipt.revision) && receipt.revision > 0)
+            .map(receipt => `${receipt.peerId}:${receipt.revision}`));
+        const ids = [];
+        const stamp = now();
+        let changed = false;
+        for (const message of this.rootInbox) {
+            if (message.source !== 'automatic-settlement' || message.kind !== 'result'
+                || !observed.has(`${message.fromAgentId}:${message.settlementRevision}`))
+                continue;
+            // Include previously acknowledged IDs so cold-restored continuation
+            // copies can be retired without changing already-consumed history.
+            ids.push(message.id);
+            if (!message.readAt) {
+                message.readAt = stamp;
+                changed = true;
+            }
+        }
+        if (changed) {
+            this.persistNow();
+            this.changed();
+        }
+        return ids;
+    }
     acknowledgeRootInbox(messageId) {
         const message = this.rootInbox.find(item => item.id === messageId && !item.readAt);
         if (!message)
@@ -253,7 +397,7 @@ class SubagentManager {
         const messages = this.mailbox.filter(message => message.toAgentId === agentId && !message.readAt);
         if (messages.length)
             this.markMailboxRead(messages);
-        return messages.map(message => ({ ...message }));
+        return messages.map(cloneMailboxMessage);
     }
     acknowledgeMailbox(agentId, messageId) {
         const message = this.mailbox.find(item => item.id === messageId && item.toAgentId === agentId && !item.readAt);
@@ -306,6 +450,8 @@ class SubagentManager {
             toAgentId: message.toAgentId,
             kind: message.kind,
             body: truncateText(message.body, 2000),
+            wakeup: message.wakeup,
+            acceptedWhileActive: message.acceptedWhileActive,
             createdAt: message.createdAt,
             readAt: message.readAt,
         }));
@@ -371,7 +517,7 @@ class SubagentManager {
         if (record)
             record.messages.push({ role: 'assistant', content });
     }
-    replaceContext(id, history, compression) {
+    replaceContext(id, history, compression, inputCommitted = false) {
         const record = this.get(id);
         if (!record)
             return;
@@ -388,7 +534,7 @@ class SubagentManager {
             if (message.name)
                 stored.name = String(message.name);
             if (Array.isArray(message.tool_calls))
-                stored.tool_calls = message.tool_calls;
+                stored.tool_calls = structuredClone(message.tool_calls);
             if (message.hidden_user_input)
                 stored.hidden_user_input = true;
             if (message.goal_continuation)
@@ -406,6 +552,19 @@ class SubagentManager {
             contextCompression: compression ? { ...compression } : null,
         };
         record.updatedAt = now();
+        const activeJob = this.activeJobs.get(record.id);
+        if (activeJob && inputCommitted)
+            activeJob.inputCommitted = true;
+        this.persistNow();
+        this.changed();
+    }
+    patchMetadata(id, patch) {
+        const record = this.get(id);
+        if (!record)
+            return;
+        record.metadata = { ...(record.metadata || {}), ...structuredClone(patch) };
+        record.updatedAt = now();
+        this.persistNow();
         this.changed();
     }
     complete(id, result) {
@@ -414,6 +573,7 @@ class SubagentManager {
             return;
         this.pending = this.pending.filter(job => job.id !== record.id);
         record.result = result;
+        record.settlementRevision = Math.max(0, Math.floor(Number(record.settlementRevision) || 0)) + 1;
         record.status = 'completed';
         record.error = undefined;
         record.completedAt = now();
@@ -430,6 +590,7 @@ class SubagentManager {
             return;
         this.pending = this.pending.filter(job => job.id !== record.id);
         record.result = `[Subagent Error] ${error}`;
+        record.settlementRevision = Math.max(0, Math.floor(Number(record.settlementRevision) || 0)) + 1;
         record.status = 'error';
         record.error = error;
         record.completedAt = now();
@@ -508,6 +669,33 @@ class SubagentManager {
     }
     listActive() { return this.listAll().filter(item => item.status !== 'closed'); }
     listAll() { return [...this.subs.values()].map(cloneRecord); }
+    /** Model-facing list: detailed transcripts and request cache remain private. */
+    listSummaries(status = '') {
+        const counts = new Map();
+        for (const message of this.mailbox) {
+            const count = counts.get(message.toAgentId) || { total: 0, unread: 0 };
+            count.total++;
+            if (!message.readAt)
+                count.unread++;
+            counts.set(message.toAgentId, count);
+        }
+        return [...this.subs.values()].filter(record => !status || record.status === status).map(record => ({
+            id: record.id, shortId: record.shortId, natureSlug: record.natureSlug,
+            displayName: record.displayName, qualifiedName: record.qualifiedName, name: record.name,
+            conversationId: record.conversationId, createdByAgentId: record.createdByAgentId,
+            buildRunId: record.buildRunId, intelligenceTier: record.intelligenceTier,
+            prompt: truncateText(record.prompt, 1200), model: record.model, inputMode: record.inputMode,
+            agentMode: record.agentMode, mode: record.agentMode, status: record.status, active: record.status !== 'closed',
+            goalObjective: record.goalObjective ? truncateText(record.goalObjective, 800) : undefined,
+            flowName: record.flowName, flowPc: record.flowPc, queueSequence: record.queueSequence,
+            resultAvailable: record.result !== null, resultChars: record.result?.length || 0,
+            settlementRevision: record.settlementRevision, messageCount: record.messages.length,
+            error: record.error ? truncateText(record.error, 512) : undefined,
+            createdAt: record.createdAt, startedAt: record.startedAt, updatedAt: record.updatedAt,
+            completedAt: record.completedAt, closedAt: record.closedAt,
+            mailbox: counts.get(record.id) || { total: 0, unread: 0 },
+        }));
+    }
     activeCountForBuild(buildRunId) {
         const target = String(buildRunId || '').trim();
         if (!target)
@@ -552,8 +740,17 @@ class SubagentManager {
             rootAgentId: this.rootAgentId,
             nextSequence: this.nextSequence,
             schedulingPaused: this.schedulingPaused,
+            jobs: [
+                ...Array.from(this.activeJobs.values(), job => ({
+                    ...job, reason: 'resume', inputCommitted: false,
+                    prompt: job.inputCommitted
+                        ? exports.SUBAGENT_RECOVERY_PROMPT
+                        : job.prompt,
+                })),
+                ...this.pending.map(job => ({ ...job })),
+            ].sort((a, b) => a.sequence - b.sequence),
             records: this.listAll().map(record => record.status === 'working' ? { ...record, status: 'queued' } : record),
-            mailbox: this.mailbox.map(message => ({ ...message })),
+            mailbox: this.mailbox.map(cloneMailboxMessage),
             rootInbox: this.rootInbox.map(message => ({ ...message })),
         };
     }
@@ -564,6 +761,7 @@ class SubagentManager {
                 existing.prompt = `${existing.prompt}\n\n${prompt}`;
             record.status = 'queued';
             record.updatedAt = now();
+            this.persistNow();
             this.changed();
             this.pump();
             return;
@@ -574,6 +772,7 @@ class SubagentManager {
         record.updatedAt = now();
         this.pending.push({ id: record.id, prompt, flowName, sequence, reason });
         this.pending.sort((a, b) => a.sequence - b.sequence);
+        this.persistNow();
         this.changed();
         this.pump();
     }
@@ -586,7 +785,8 @@ class SubagentManager {
         if (record.status === 'closed')
             return;
         const unread = this.unreadMailbox(record.id);
-        if (!unread.length)
+        const activating = unread.find(message => message.wakeup || message.acceptedWhileActive);
+        if (!activating)
             return;
         if (record.status === 'queued') {
             const existing = this.pending.find(job => job.id === record.id);
@@ -598,17 +798,19 @@ class SubagentManager {
             return;
         }
         record.status = 'queued';
-        const sequence = Number(record.queueSequence || unread[0].sequence || this.nextSequence++);
+        const sequence = Number(record.queueSequence || activating.sequence || this.nextSequence++);
         record.queueSequence = sequence;
-        this.pending.push({ id: record.id, prompt: this.mailboxPrompt(unread), flowName: record.flowName || '', sequence, reason: 'mailbox' });
+        this.pending.push({ id: record.id, prompt: '', flowName: record.flowName || '', sequence, reason: 'mailbox' });
     }
     enqueueUnreadMailbox(record) {
         if (record.status === 'closed' || record.status === 'queued' || this.running.has(record.id))
             return;
         const unread = this.unreadMailbox(record.id);
-        if (!unread.length)
+        if (!unread.some(message => message.wakeup || message.acceptedWhileActive))
             return;
-        this.enqueue(record, this.mailboxPrompt(unread), record.flowName || '', 'mailbox');
+        // Store the mailbox once. pump() builds the current batch at dispatch so
+        // later arrivals coalesce without duplicating the initial wake message.
+        this.enqueue(record, '', record.flowName || '', 'mailbox');
     }
     markMailboxRead(messages) {
         const stamp = now();
@@ -655,24 +857,45 @@ class SubagentManager {
             const record = this.subs.get(job.id);
             if (!record || record.status === 'closed')
                 continue;
-            const unread = this.consumeMailbox(record.id);
-            const prompt = unread.length ? `${job.prompt}\n\n${this.mailboxPrompt(unread)}` : job.prompt;
+            const unread = this.unreadMailbox(record.id);
+            const prompt = [job.prompt, unread.length ? this.mailboxPrompt(unread) : ''].filter(Boolean).join('\n\n');
             record.status = 'working';
             record.queueSequence = undefined;
             record.startedAt = record.startedAt || now();
             record.updatedAt = now();
             this.running.add(record.id);
+            const activeJob = { ...job, prompt };
+            this.activeJobs.set(record.id, activeJob);
+            // A read receipt must never reach disk without the precise dispatched
+            // input. Cold restore can now recover a job even before child startup.
+            if (unread.length)
+                this.markMailboxRead(unread);
+            else
+                this.persistNow();
             this.changed();
-            void this.executor({ record: cloneRecord(record), prompt, flowName: job.flowName, reason: job.reason })
+            let execution;
+            try {
+                execution = Promise.resolve(this.executor({ record: cloneRecord(record), prompt, flowName: job.flowName, reason: job.reason }));
+            }
+            catch (error) {
+                execution = Promise.reject(error);
+            }
+            void execution
                 .then(result => {
+                if (this.activeJobs.get(record.id) !== activeJob)
+                    return;
                 this.complete(record.id, result || '[Subagent] Completed with empty response.');
                 this.running.delete(record.id);
+                this.activeJobs.delete(record.id);
                 this.enqueueUnreadMailbox(record);
                 this.pump();
             })
                 .catch(error => {
+                if (this.activeJobs.get(record.id) !== activeJob)
+                    return;
                 this.fail(record.id, error instanceof Error ? error.message : String(error));
                 this.running.delete(record.id);
+                this.activeJobs.delete(record.id);
                 this.enqueueUnreadMailbox(record);
                 this.pump();
             });

package/dist/core/subagentCommunication.d.ts

@@ -0,0 +1,43 @@
+/** Sender-owned, explicit content selection for peer communication.
+ * Selection never calls a model, mutates history, or serializes runtime state.
+ */
+export type SubagentCommunicationContentKind = 'summary' | 'text_history' | 'tool_history';
+export interface SubagentCommunicationHistoryMessage {
+    role?: unknown;
+    content?: unknown;
+    tool_calls?: unknown;
+    tool_call_id?: unknown;
+    name?: unknown;
+    hidden_user_input?: unknown;
+}
+export interface SubagentCommunicationParams {
+    message?: unknown;
+    prompt?: unknown;
+    content?: unknown;
+}
+export interface SubagentCommunicationRange {
+    start: number;
+    end: number;
+    total: number;
+}
+export interface SubagentCommunicationSelection {
+    body: string;
+    selection: {
+        source: 'explicit' | 'default_history' | 'content';
+        segments: Array<{
+            kind: 'message' | SubagentCommunicationContentKind;
+            range?: SubagentCommunicationRange;
+            units: number;
+        }>;
+        bodyChars: number;
+    };
+}
+export type SubagentCommunicationErrorCode = 'ambiguous_content' | 'invalid_content' | 'invalid_range' | 'empty_history' | 'budget_exceeded';
+export declare class SubagentCommunicationSelectionError extends Error {
+    readonly code: SubagentCommunicationErrorCode;
+    constructor(code: SubagentCommunicationErrorCode, message: string);
+}
+export declare function selectSubagentCommunication(history: readonly SubagentCommunicationHistoryMessage[], params: SubagentCommunicationParams, options?: {
+    maxBodyChars?: number;
+}): SubagentCommunicationSelection;
+//# sourceMappingURL=subagentCommunication.d.ts.map