@borgee/agents-host 0.2.2 → 0.2.28

package/dist/agents-host.js

@@ -1,33 +1,280 @@
-import { chmod, mkdir } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import { chmod, link, mkdir, readFile, readdir, rename, unlink, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
 import { SdkChatControlPlane } from './chat/sdk-chat-control-plane.js';
+import { HostLogger, summarizeError } from './debug.js';
 import { createDurableCursorStore } from './durable-cursor-store.js';
+import { ATTENTION_FOLLOW_SEMANTICS_COMPATIBILITY_GATE, COLLABORATION_CAPABILITIES_DIAGNOSTICS_COMPATIBILITY_GATE, COLLABORATION_OUTCOME_MODEL_COMPATIBILITY_GATE, COLLABORATION_SKILL_FIRST_COMPATIBILITY_GATE, CONTEXT_INJECTION_COMPATIBILITY_GATE, LOCALHOST_GATEWAY_COMPATIBILITY_GATE, POLICY_AUDIT_ENFORCEMENT_COMPATIBILITY_GATE, resolveInternalPolicyMode, resolveInternalCompatibilityGates, SKILL_RUNTIME_COMPATIBILITY_GATE, TASK_THREAD_COLLABORATION_CONTRACT_COMPATIBILITY_GATE, TOKEN_BINDING_COMPATIBILITY_GATE, } from './compatibility-gates.js';
+import { buildNormalizedAttentionSnapshot, parsePersistedAttentionSnapshot, } from './context/attention.js';
+import { projectTaskThreadCollaborationContract } from './context/task-thread-collaboration.js';
+import { createLocalhostGatewayController, LOCALHOST_GATEWAY_COLLABORATION_TARGET_COOLDOWN_MS, } from './gateway/localhost-gateway.js';
+import { extractTaskIdFromTaskAssignmentContent, resolveChannelContextPayloadPath, } from './context/injection.js';
+import { AuthorizationAuditSink, } from './policy/authorization-audit.js';
 import { createProvider } from './providers/create-provider.js';
+import { resolveAttentionStatePath, resolveSharedProtocolKickoffDecisionPath, resolveSharedProtocolStatusPath, } from './state-paths.js';
+import { appendVisibleMention as appendVisibleBodyMention, extractVisibleMentionIds as extractCanonicalMentionIds, } from './visible-mentions.js';
+import { waitForTaskForThread } from './task-thread-resolution.js';
 const PRIVATE_STATE_ROOT_MODE = 0o700;
 const STREAM_PROGRESS_EDIT_THROTTLE_MS = 150;
+const PROTOCOL_STATE_DIRNAME = 'protocol-state';
+const PROTOCOL_PROVIDER_TURN_TIMEOUT_MS = 120_000;
+const PROTOCOL_KICKOFF_DECISION_TIMEOUT_MS = PROTOCOL_PROVIDER_TURN_TIMEOUT_MS;
+const PROTOCOL_KICKOFF_DECISION_POLL_INTERVAL_MS = 50;
+const PROTOCOL_KICKOFF_ROUND_LIMIT = 20;
+const COLLABORATION_LATE_SEND_GRACE_MS = 5_000;
+const ORDINARY_HUMAN_EVENT_KINDS = new Set(['', 'message']);
 async function ensurePrivateStateRoot(path) {
     await mkdir(path, { recursive: true, mode: PRIVATE_STATE_ROOT_MODE });
     await chmod(path, PRIVATE_STATE_ROOT_MODE);
 }
+function matchesProtocolStateIdentity(left, right) {
+    return (left.anchorMessageId === right.anchorMessageId &&
+        left.issuerId === right.issuerId &&
+        left.participantIds[0] === right.participantIds[0] &&
+        left.participantIds[1] === right.participantIds[1]);
+}
+function shouldAdoptPeerProtocolState(current, candidate, selfAgentId) {
+    if (!matchesProtocolStateIdentity(current, candidate)) {
+        return false;
+    }
+    if (candidate.currentTurnIndex !== current.currentTurnIndex) {
+        return candidate.currentTurnIndex > current.currentTurnIndex;
+    }
+    if ((candidate.finished && !current.finished) || (!candidate.active && current.active)) {
+        return true;
+    }
+    if (!current.lastProtocolMessageId && candidate.lastProtocolMessageId) {
+        return true;
+    }
+    if (current.expectedNextSpeakerId !== selfAgentId &&
+        candidate.expectedNextSpeakerId === selfAgentId) {
+        return true;
+    }
+    return false;
+}
+async function writePrivateJsonFile(path, value, options) {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    const content = `${JSON.stringify(value, null, 2)}\n`;
+    const temporaryPath = `${path}.${randomUUID()}.tmp`;
+    await writeFile(temporaryPath, content, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+    try {
+        if (options?.exclusive) {
+            await link(temporaryPath, path);
+            await unlink(temporaryPath);
+            return;
+        }
+        await rename(temporaryPath, path);
+    }
+    catch (error) {
+        await unlink(temporaryPath).catch(() => { });
+        throw error;
+    }
+}
+class DefaultHostRuntime {
+    config;
+    provider;
+    controlPlane;
+    ensureStateRoot;
+    gateway;
+    authorizationAuditSink;
+    logger;
+    constructor(config, deps) {
+        this.config = config;
+        this.logger = deps.logger;
+        const compatibilityGates = resolveInternalCompatibilityGates();
+        const contextInjectionGateEnabled = compatibilityGates.has(CONTEXT_INJECTION_COMPATIBILITY_GATE);
+        const skillRuntimeGateEnabled = compatibilityGates.has(SKILL_RUNTIME_COMPATIBILITY_GATE);
+        const localhostGatewayGateEnabled = contextInjectionGateEnabled &&
+            skillRuntimeGateEnabled &&
+            compatibilityGates.has(LOCALHOST_GATEWAY_COMPATIBILITY_GATE);
+        const tokenBindingGateEnabled = compatibilityGates.has(TOKEN_BINDING_COMPATIBILITY_GATE);
+        const policyAuditGateEnabled = compatibilityGates.has(POLICY_AUDIT_ENFORCEMENT_COMPATIBILITY_GATE);
+        const policyMode = resolveInternalPolicyMode(policyAuditGateEnabled);
+        const collaborationEnabled = localhostGatewayGateEnabled &&
+            compatibilityGates.has(COLLABORATION_SKILL_FIRST_COMPATIBILITY_GATE) &&
+            policyAuditGateEnabled &&
+            policyMode === 'enforce';
+        this.authorizationAuditSink = policyAuditGateEnabled
+            ? new AuthorizationAuditSink({
+                stateRootDir: config.stateRootDir,
+                logger: deps.logger,
+            })
+            : undefined;
+        this.controlPlane =
+            deps.borgee ??
+                new SdkChatControlPlane(config.borgeeBaseUrl, config.agent.agentApiKey, undefined, {
+                    cursorStore: createDurableCursorStore({
+                        stateRootDir: config.stateRootDir,
+                    }),
+                    pluginId: `agents-host:${config.agent.provider}`,
+                });
+        this.gateway = createLocalhostGatewayController({
+            gateEnabled: localhostGatewayGateEnabled,
+            collaborationEnabled,
+            tokenBindingGateEnabled,
+            policyAuditGateEnabled,
+            policyMode,
+            controlPlane: this.controlPlane,
+            stateRootDir: config.stateRootDir,
+            resolveStableAgentId: deps.resolveStableAgentId,
+            logger: deps.logger,
+            auditSink: this.authorizationAuditSink,
+            authorizeCollaborationSend: deps.authorizeCollaborationSend,
+            readCollaborationDraft: deps.readCollaborationDraft,
+        });
+        this.provider =
+            deps.provider ??
+                createProvider({
+                    provider: config.agent.provider,
+                    stateRootDir: config.stateRootDir,
+                    resolveStableAgentId: deps.resolveStableAgentId,
+                    claudeCommand: config.claudeCommand,
+                    claudeArgs: config.claudeArgs,
+                    codexCommand: config.codexCommand,
+                    codexArgs: config.codexArgs,
+                    copilotCommand: config.copilotCommand,
+                    copilotArgs: config.copilotArgs,
+                    copilotSessionTtlMinutes: config.copilotSessionTtlMinutes,
+                }, deps.logger, {
+                    compatibilityGates,
+                    authorizationAuditSink: this.authorizationAuditSink,
+                    localhostGateway: localhostGatewayGateEnabled ? this.gateway.contextPublisher : undefined,
+                });
+        this.ensureStateRoot = deps.ensureStateRoot ?? ensurePrivateStateRoot;
+    }
+    async start(onMessage) {
+        await this.ensureStateRoot(this.config.stateRootDir);
+        await this.gateway.start();
+        try {
+            await this.controlPlane.connect(onMessage);
+        }
+        catch (error) {
+            await this.gateway.stop().catch(() => { });
+            throw error;
+        }
+    }
+    async stop() {
+        let thrown;
+        try {
+            await this.controlPlane.close();
+        }
+        catch (error) {
+            thrown = error;
+        }
+        try {
+            await this.gateway.stop();
+        }
+        catch (error) {
+            thrown ??= error;
+        }
+        try {
+            await this.provider.dispose?.();
+        }
+        catch (error) {
+            thrown ??= error;
+        }
+        try {
+            await this.authorizationAuditSink?.drain();
+        }
+        catch (error) {
+            this.logger.error('authorization audit drain failed during shutdown', {
+                error: summarizeError(error),
+            });
+        }
+        if (thrown) {
+            throw thrown;
+        }
+    }
+}
+function createDefaultHostRuntime(config, deps) {
+    return new DefaultHostRuntime(config, deps);
+}
 function hasVisibleText(value) {
     return value.trim().length > 0;
 }
+function extractDispatchMentionIds(content) {
+    return [
+        ...content.matchAll(/(?:^|[^A-Za-z0-9_])@([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|[0-9A-HJKMNP-TV-Z]{26})/gu),
+    ]
+        .map((match) => match[1]?.trim())
+        .filter((value) => Boolean(value));
+}
+function hasCanonicalBodyMention(content, participantId) {
+    return extractCanonicalMentionIds(content).includes(participantId);
+}
+function hasRelayBodyMention(content, participantId) {
+    return (hasCanonicalBodyMention(content, participantId) ||
+        extractDispatchMentionIds(content).includes(participantId));
+}
+function encodeStatePathSegment(value) {
+    const encoded = Buffer.from(value, 'utf8').toString('hex');
+    return encoded.length > 0 ? encoded : 'empty';
+}
+function decodeStatePathSegment(value) {
+    if (value === 'empty') {
+        return '';
+    }
+    if (!/^(?:[0-9a-f]{2})+$/u.test(value)) {
+        return null;
+    }
+    return Buffer.from(value, 'hex').toString('utf8');
+}
+function summarizeAnchorContent(content) {
+    const collapsed = content.replace(/\s+/gu, ' ').trim();
+    if (collapsed.length <= 160) {
+        return collapsed;
+    }
+    return `${collapsed.slice(0, 157)}...`;
+}
+function nextProtocolFallbackDeadline(now = Date.now()) {
+    return now + PROTOCOL_PROVIDER_TURN_TIMEOUT_MS;
+}
+function nextProtocolKickoffDecisionDeadline(now = Date.now()) {
+    return now + PROTOCOL_KICKOFF_DECISION_TIMEOUT_MS;
+}
+function delay(ms) {
+    return new Promise((resolveDelay) => {
+        setTimeout(resolveDelay, ms);
+    });
+}
+function isReplyTriggeringEventType(eventType) {
+    if (eventType == null) {
+        return true;
+    }
+    const normalized = eventType.trim();
+    // The SDK forwards lowercase inbound kind literals into ChannelMessageEvent.type.
+    return normalized === '' || normalized === 'message' || normalized === 'mention';
+}
+function resolvePublicReplyText(reply) {
+    if (reply.controlMalformed) {
+        return '';
+    }
+    if (hasVisibleText(reply.text)) {
+        return reply.text;
+    }
+    return reply.awaitingUser?.question ?? '';
+}
 function providerUsesDraftProgress(provider) {
-    return provider === 'claude' || provider === 'copilot';
+    return provider === 'claude' || provider === 'codex' || provider === 'copilot';
 }
 class DraftMessageController {
     borgee;
     channelId;
     canWrite;
+    logger;
+    creationMetadata;
     messageId = null;
     currentBody = '';
     pendingBody = null;
     timer = null;
     sealed = false;
     writeChain = Promise.resolve();
-    constructor(borgee, channelId, canWrite) {
+    constructor(borgee, channelId, canWrite, logger, creationMetadata) {
         this.borgee = borgee;
         this.channelId = channelId;
         this.canWrite = canWrite;
+        this.logger = logger;
+        this.creationMetadata = creationMetadata;
     }
     update(text) {
         if (this.sealed || !hasVisibleText(text)) {
@@ -40,7 +287,7 @@ class DraftMessageController {
         this.timer = setTimeout(() => {
             this.timer = null;
             void this.flushPending().catch((error) => {
-                console.error('[agents-host] failed to flush draft progress:', error);
+                this.logger.error('failed to flush draft progress', error);
             });
         }, STREAM_PROGRESS_EDIT_THROTTLE_MS);
     }
@@ -60,7 +307,7 @@ class DraftMessageController {
         if (hasVisibleText(finalText)) {
             this.pendingBody = finalText;
             await this.flushPending();
-            return;
+            return this.messageId;
         }
         await this.enqueueWrite(async () => {
             if (!this.canWrite() || !this.messageId) {
@@ -71,6 +318,7 @@ class DraftMessageController {
             this.currentBody = '';
             this.pendingBody = null;
         });
+        return null;
     }
     async discard() {
         this.sealed = true;
@@ -80,7 +328,7 @@ class DraftMessageController {
         }
         this.pendingBody = null;
         await this.enqueueWrite(async () => {
-            if (!this.canWrite() || !this.messageId) {
+            if (!this.messageId) {
                 return;
             }
             await this.borgee.deleteMessage(this.messageId);
@@ -98,7 +346,11 @@ class DraftMessageController {
                 await this.borgee.editMessage(this.messageId, body);
             }
             else {
-                const posted = await this.borgee.postMessage(this.channelId, body);
+                const posted = await this.borgee.postMessage({
+                    channelId: this.channelId,
+                    body,
+                    replyToId: this.creationMetadata?.replyToId,
+                });
                 this.messageId = posted.messageId;
             }
             this.currentBody = body;
@@ -109,201 +361,2520 @@ class DraftMessageController {
         return this.writeChain;
     }
 }
+const BLOCKED_AUTHOR_REFRESH_BACKOFF_MS = 1_000;
+const MAX_QUEUED_MESSAGES_PER_CHANNEL = 8;
+const COLLABORATION_SENDS_PER_TURN = 1;
 /**
  * Minimal single-agent agents host: connects one local Claude/Copilot CLI
  * to exactly one Borgee agent over `@borgee/plugin-sdk` (BPP / `/ws/plugin`).
- *
- * Conversation memory is handled entirely by each provider's native
- * per-channel CLI session (Claude `--resume`, Copilot `--session-id`) — see
- * the cli-client.ts file under each provider's folder. This class does not
- * keep any message history itself.
- *
- * Out of scope for this single-agent runner (see README): execution/remote-command
- * dispatch, node provisioning, systemd install, and scheduled (periodic)
- * prompts. Multi-agent local hosting is handled one level up by the local-config
- * supervisor, which creates one isolated `AgentsHost` per effective agent key.
- *
- * Message gating (mention-only / DM rules) is NOT done here: the server
- * enforces per-agent + per-channel `require_mention` at BPP fan-out, so this
- * host simply replies to every message it is handed (minus its own).
  */
 export class AgentsHost {
     config;
+    runtime;
     provider;
     borgee;
+    logger;
+    contextInjectionEnabled;
+    collaborationEnabled;
+    collaborationOutcomeModelEnabled;
+    attentionFollowSemanticsEnabled;
+    taskThreadCollaborationContractEnabled;
+    collaborationCapabilitiesDiagnosticsEnabled;
     activeTurns = new Set();
+    awaitingUserByChannel = new Map();
+    collaborationOutcomeByChannel = new Map();
+    attentionSnapshotByChannel = new Map();
+    missedCollaborationDiagnosticByChannel = new Map();
     progressChannelQueues = new Map();
     progressDrafts = new Map();
+    collaborationDrafts = new Map();
+    collaborationChannels = new Map();
+    participantDirectoryByUserId = new Map();
+    participantKindsByUserId = new Map();
+    participantRefreshBackoffByUserId = new Map();
+    participantRefreshPromise = null;
+    participantDirectorySupported = true;
     selfAgentId = null;
+    selfAgentProfile = null;
     selfAgentIdPromise = null;
     started = false;
     controlPlaneClosed = false;
     constructor(config, deps) {
         this.config = config;
-        this.provider = deps?.provider ?? createProvider({
-            provider: config.agent.provider,
-            stateRootDir: config.stateRootDir,
+        this.logger = new HostLogger(deps?.runtimeOptions);
+        const compatibilityGates = resolveInternalCompatibilityGates();
+        const contextInjectionGateEnabled = compatibilityGates.has(CONTEXT_INJECTION_COMPATIBILITY_GATE);
+        this.contextInjectionEnabled = contextInjectionGateEnabled;
+        const skillRuntimeGateEnabled = compatibilityGates.has(SKILL_RUNTIME_COMPATIBILITY_GATE);
+        const localhostGatewayGateEnabled = contextInjectionGateEnabled &&
+            skillRuntimeGateEnabled &&
+            compatibilityGates.has(LOCALHOST_GATEWAY_COMPATIBILITY_GATE);
+        const policyAuditGateEnabled = compatibilityGates.has(POLICY_AUDIT_ENFORCEMENT_COMPATIBILITY_GATE);
+        this.collaborationEnabled =
+            localhostGatewayGateEnabled &&
+                compatibilityGates.has(COLLABORATION_SKILL_FIRST_COMPATIBILITY_GATE) &&
+                policyAuditGateEnabled &&
+                resolveInternalPolicyMode(policyAuditGateEnabled) === 'enforce';
+        this.collaborationOutcomeModelEnabled = compatibilityGates.has(COLLABORATION_OUTCOME_MODEL_COMPATIBILITY_GATE);
+        this.attentionFollowSemanticsEnabled = compatibilityGates.has(ATTENTION_FOLLOW_SEMANTICS_COMPATIBILITY_GATE);
+        this.taskThreadCollaborationContractEnabled =
+            contextInjectionGateEnabled
+                && compatibilityGates.has(TASK_THREAD_COLLABORATION_CONTRACT_COMPATIBILITY_GATE);
+        this.collaborationCapabilitiesDiagnosticsEnabled =
+            contextInjectionGateEnabled
+                && compatibilityGates.has(COLLABORATION_CAPABILITIES_DIAGNOSTICS_COMPATIBILITY_GATE);
+        this.runtime = createDefaultHostRuntime(config, {
+            logger: this.logger,
+            provider: deps?.provider,
+            borgee: deps?.borgee,
             resolveStableAgentId: () => this.selfAgentId ?? undefined,
-            claudeCommand: config.claudeCommand,
-            claudeArgs: config.claudeArgs,
-            copilotCommand: config.copilotCommand,
-            copilotArgs: config.copilotArgs,
-            copilotSessionTtlMinutes: config.copilotSessionTtlMinutes,
-        });
-        this.borgee = deps?.borgee ?? new SdkChatControlPlane(config.borgeeBaseUrl, config.agent.agentApiKey, undefined, {
-            cursorStore: createDurableCursorStore({
-                stateRootDir: config.stateRootDir,
-            }),
-            // Lets the server know which runtime/provider actually connected
-            // (internal/bpp ConnectHandler → users.last_connected_plugin_id), so
-            // the web UI can show real state instead of a client-side guess.
-            pluginId: `agents-host:${config.agent.provider}`,
+            readCollaborationDraft: (input) => this.readCollaborationDraft(input),
+            authorizeCollaborationSend: (input) => this.authorizeCollaborationSend(input),
         });
+        this.provider = this.runtime.provider;
+        this.borgee = this.runtime.controlPlane;
     }
     async start() {
         if (this.started)
             return;
         this.started = true;
         this.controlPlaneClosed = false;
-        await ensurePrivateStateRoot(this.config.stateRootDir);
-        await this.borgee.connect((message) => {
-            if (!this.started) {
-                return;
-            }
-            const task = providerUsesDraftProgress(this.config.agent.provider)
-                ? this.enqueueProgressChannelTurn(message.channel_id, () => this.handleMessage(message))
-                : this.handleMessage(message);
-            this.trackActiveTurn(task);
-        });
-        const agentId = await this.ensureSelfAgentId();
-        console.log('[agents-host] connected', {
-            agentId,
-            agentName: this.config.agent.agentName,
+        this.logger.debug('starting host', {
             provider: this.config.agent.provider,
+            agentName: this.config.agent.agentName,
+            stateRootDir: this.config.stateRootDir,
+            collaborationEnabled: this.collaborationEnabled,
         });
+        const bufferedMessages = [];
+        let bufferingMessages = true;
+        try {
+            await this.runtime.start((message) => {
+                if (!this.started) {
+                    return;
+                }
+                if (bufferingMessages) {
+                    bufferedMessages.push(message);
+                    return;
+                }
+                this.dispatchMessage(message);
+            });
+            const agentId = await this.ensureSelfAgentId();
+            bufferingMessages = false;
+            while (bufferedMessages.length > 0) {
+                const pendingMessages = bufferedMessages.splice(0, bufferedMessages.length);
+                for (const message of pendingMessages) {
+                    this.dispatchMessage(message);
+                }
+            }
+            this.logger.debug('connected host', {
+                agentId,
+                agentName: this.config.agent.agentName,
+                provider: this.config.agent.provider,
+            });
+        }
+        catch (error) {
+            bufferingMessages = false;
+            bufferedMessages.length = 0;
+            this.started = false;
+            this.controlPlaneClosed = true;
+            await this.runtime.stop().catch(() => { });
+            throw error;
+        }
     }
     async stop() {
         if (!this.started)
             return;
         this.started = false;
+        this.logger.debug('stopping host', {
+            activeTurnCount: this.activeTurns.size,
+            provider: this.config.agent.provider,
+            agentName: this.config.agent.agentName,
+        });
+        for (const channelId of this.collaborationChannels.keys()) {
+            this.invalidateChannelTurn(channelId);
+            this.clearProtocolFallback(this.collaborationChannels.get(channelId));
+        }
         for (const draft of this.progressDrafts.values()) {
             draft.cancelProgress();
         }
+        for (const channelId of [...this.collaborationDrafts.keys()]) {
+            this.clearCollaborationDraft(channelId);
+        }
+        this.awaitingUserByChannel.clear();
+        this.collaborationOutcomeByChannel.clear();
+        this.attentionSnapshotByChannel.clear();
+        this.missedCollaborationDiagnosticByChannel.clear();
         this.controlPlaneClosed = true;
-        await this.borgee.close();
-        await this.provider.dispose?.();
+        await this.runtime.stop();
         await Promise.allSettled([...this.activeTurns]);
     }
-    async handleMessage(msg) {
-        console.log('[agents-host] received message', {
-            eventType: msg.type,
-            provider: this.config.agent.provider,
-            agentName: this.config.agent.agentName,
-            channelId: msg.channel_id,
+    trackActiveTurn(task) {
+        this.activeTurns.add(task);
+        void task.finally(() => {
+            this.activeTurns.delete(task);
         });
-        const selfAgentId = await this.ensureSelfAgentId();
-        const authorId = String(msg.user_id ?? msg.sender_id ?? 'unknown');
-        if (authorId === selfAgentId) {
+    }
+    dispatchMessage(message) {
+        const task = this.collaborationEnabled
+            ? this.handleCollaborationMessage(message)
+            : providerUsesDraftProgress(this.config.agent.provider)
+                ? this.enqueueProgressChannelTurn(message.channel_id, () => this.handleLegacyMessage(message))
+                : this.handleLegacyMessage(message);
+        this.trackActiveTurn(task);
+    }
+    async handleLegacyMessage(msg) {
+        const normalized = await this.normalizeMessage(msg);
+        if (!normalized) {
             return;
         }
-        const content = String(msg.content ?? msg.body ?? '').trim();
-        if (!content)
-            return;
-        // No client-side mention/DM gating here: the server already decides which
-        // messages an agent receives (per-agent + per-channel require_mention is
-        // enforced at BPP fan-out via AgentReceivesChannelMessage). If a channel
-        // message reaches this host at all, the agent is meant to handle it.
-        const stopTyping = this.borgee.startTyping(msg.channel_id);
-        const useDraftProgress = providerUsesDraftProgress(this.config.agent.provider);
-        try {
-            const reply = await this.provider.generateReply({
-                agentName: this.config.agent.agentName,
-                provider: this.config.agent.provider,
-                channelId: msg.channel_id,
-                incomingAuthorId: authorId,
-                incomingContent: content,
-            }, useDraftProgress
-                ? {
-                    onProgress: (update) => {
-                        if (!this.started || this.controlPlaneClosed) {
-                            return;
-                        }
-                        this.ensureProgressDraft(msg.channel_id).update(update.text);
-                    },
+        let taskThreadContext = { state: 'inactive' };
+        let attentionSnapshot;
+        if (this.attentionFollowSemanticsEnabled
+            || this.taskThreadCollaborationContractEnabled) {
+            taskThreadContext = await this.buildTurnTaskThreadContext(msg, msg.channel_id);
+            if (this.attentionFollowSemanticsEnabled) {
+                const channelState = this.ensureCollaborationChannelState(msg.channel_id);
+                const authorKind = await this.classifyAuthor(normalized.authorId, false);
+                await this.ensureAttentionSnapshotLoaded(msg.channel_id, channelState);
+                attentionSnapshot = this.getAttentionSnapshotForTurn(msg.channel_id, taskThreadContext);
+                if (this.isHumanWakeFiltered(msg, authorKind, attentionSnapshot)) {
+                    return;
                 }
-                : undefined);
-            if (useDraftProgress) {
-                const draft = this.progressDrafts.get(msg.channel_id);
-                if (!this.started) {
-                    await draft?.discard().catch(() => { });
-                    this.progressDrafts.delete(msg.channel_id);
+            }
+        }
+        if (msg.message_type === 'task_assignment') {
+            await this.markAssignedTaskInProgress(msg.channel_id, normalized.content);
+        }
+        await this.runUngatedTurn(msg, normalized.authorId, normalized.content, taskThreadContext, attentionSnapshot);
+    }
+    async handleCollaborationMessage(msg) {
+        const normalized = await this.normalizeMessage(msg);
+        if (!normalized) {
+            return;
+        }
+        if (msg.message_type === 'task_assignment') {
+            await this.markAssignedTaskInProgress(msg.channel_id, normalized.content);
+        }
+        const channelState = this.ensureCollaborationChannelState(msg.channel_id);
+        await this.ensureProtocolStateLoaded(msg.channel_id, channelState);
+        await this.ensureAttentionSnapshotLoaded(msg.channel_id, channelState);
+        const selfAgentId = await this.ensureSelfAgentId();
+        const authorKind = await this.classifyAuthor(normalized.authorId, false);
+        const taskThreadContext = await this.buildTurnTaskThreadContext(msg, msg.channel_id);
+        const attentionSnapshot = this.getAttentionSnapshotForTurn(msg.channel_id, taskThreadContext);
+        if (channelState.protocol?.active) {
+            if (msg.message_id && authorKind === 'agent') {
+                await this.handleActiveProtocolParticipantMessage(msg, normalized, channelState, channelState.protocol, selfAgentId);
+                if (channelState.protocol?.active ||
+                    channelState.queue.some((message) => message.kind === 'protocol-turn')) {
+                    await this.ensureCollaborationProcessor(msg.channel_id, channelState);
                     return;
                 }
-                await (draft ?? this.ensureProgressDraft(msg.channel_id)).finalize(reply.text);
-                this.progressDrafts.delete(msg.channel_id);
             }
-            else if (this.started && !this.controlPlaneClosed) {
-                await this.borgee.postMessage(msg.channel_id, reply.text);
+            if (authorKind !== 'agent') {
+                if (msg.message_id === channelState.protocol.anchorMessageId) {
+                    await this.handleActiveProtocolAnchorReplay(msg, normalized, channelState, channelState.protocol, selfAgentId);
+                    return;
+                }
+                this.cancelProtocolState(msg.channel_id, channelState);
             }
         }
-        catch (error) {
-            if (useDraftProgress) {
-                const draft = this.progressDrafts.get(msg.channel_id);
-                if (draft) {
-                    await draft.discard().catch(() => { });
-                    this.progressDrafts.delete(msg.channel_id);
+        if (channelState.blocked) {
+            const blockedAuthorKind = await this.classifyBlockedWakeAuthor(normalized.authorId, channelState.blocked);
+            if (blockedAuthorKind === 'agent') {
+                channelState.blocked.suppressedAgentMessages += 1;
+                this.recordBlockedSuppressionOutcome(msg.channel_id, channelState);
+                return;
+            }
+            if (blockedAuthorKind === 'unknown') {
+                this.enqueueCollaborationMessage(channelState, {
+                    raw: msg,
+                    authorId: normalized.authorId,
+                    authorKind: 'unknown',
+                    content: normalized.content,
+                    attentionSnapshot,
+                    taskThreadContext,
+                });
+                const resumed = await this.tryResumeBlockedFromQueue(msg.channel_id, channelState);
+                if (resumed) {
+                    await this.ensureCollaborationProcessor(msg.channel_id, channelState);
                 }
+                return;
             }
-            console.error('[agents-host] failed to generate or send reply:', {
-                provider: this.config.agent.provider,
-                agentName: this.config.agent.agentName,
-                error,
-            });
+            const wakeBlockedState = channelState.blocked.awaitingUser;
+            channelState.blocked = undefined;
+            this.awaitingUserByChannel.delete(msg.channel_id);
+            channelState.queue = [
+                {
+                    raw: msg,
+                    authorId: normalized.authorId,
+                    authorKind: 'human',
+                    content: normalized.content,
+                    attentionSnapshot,
+                    taskThreadContext,
+                    wakeBlockedState,
+                },
+            ];
+            await this.ensureCollaborationProcessor(msg.channel_id, channelState);
+            return;
         }
-        finally {
-            stopTyping();
+        if (authorKind !== 'agent') {
+            const protocolCandidate = this.detectProtocolKickoffCandidate(msg.message_id, normalized.content, selfAgentId);
+            if (protocolCandidate) {
+                const protocolRequest = await this.resolveProtocolKickoffRequest(msg, normalized, protocolCandidate, selfAgentId);
+                if (protocolRequest) {
+                    await this.startProtocolForAnchor(msg, normalized, channelState, protocolRequest, selfAgentId);
+                    return;
+                }
+            }
         }
-    }
-    trackActiveTurn(task) {
-        this.activeTurns.add(task);
-        void task.finally(() => {
-            this.activeTurns.delete(task);
+        if (this.isHumanWakeFiltered(msg, authorKind, attentionSnapshot)) {
+            return;
+        }
+        if (authorKind !== 'agent' && channelState.activeTurn) {
+            this.supersedeActiveTurn(msg.channel_id, channelState.activeTurn);
+        }
+        if (authorKind !== 'agent') {
+            channelState.recentTurn = undefined;
+        }
+        this.enqueueCollaborationMessage(channelState, {
+            raw: msg,
+            authorId: normalized.authorId,
+            authorKind,
+            content: normalized.content,
+            attentionSnapshot,
+            taskThreadContext,
         });
+        await this.ensureCollaborationProcessor(msg.channel_id, channelState);
     }
-    enqueueProgressChannelTurn(channelId, task) {
-        const previous = this.progressChannelQueues.get(channelId) ?? Promise.resolve();
-        const next = previous
-            .catch(() => { })
-            .then(task)
-            .finally(() => {
-            if (this.progressChannelQueues.get(channelId) === next) {
-                this.progressChannelQueues.delete(channelId);
+    detectProtocolKickoffCandidate(anchorMessageId, content, selfAgentId) {
+        if (!anchorMessageId) {
+            return null;
+        }
+        const mentions = extractCanonicalMentionIds(content);
+        if (mentions.length !== 2) {
+            return null;
+        }
+        const unique = [...new Set(mentions)].sort();
+        if (unique.length !== 2 || !unique.includes(selfAgentId)) {
+            return null;
+        }
+        return {
+            anchorMessageId,
+            participantIds: [unique[0], unique[1]],
+            issuerId: unique[0],
+        };
+    }
+    async validateProtocolKickoffCandidate(anchorAuthorId, protocolCandidate, selfAgentId) {
+        const anchorAuthorKind = await this.classifyAuthor(anchorAuthorId, true);
+        if (anchorAuthorKind === 'agent') {
+            return null;
+        }
+        if (protocolCandidate.participantIds.includes(anchorAuthorId)) {
+            return null;
+        }
+        for (const participantId of protocolCandidate.participantIds) {
+            if (participantId === selfAgentId) {
+                continue;
             }
+            const participantKind = await this.classifyAuthor(participantId, true);
+            if (participantKind === 'human') {
+                return null;
+            }
+        }
+        return protocolCandidate;
+    }
+    async resolveProtocolKickoffRequest(msg, normalized, protocolCandidate, selfAgentId) {
+        const validatedCandidate = await this.validateProtocolKickoffCandidate(normalized.authorId, protocolCandidate, selfAgentId);
+        if (!validatedCandidate) {
+            return null;
+        }
+        const pendingDecision = await this.ensureProtocolKickoffDecisionRecord(msg.channel_id, validatedCandidate);
+        if (!pendingDecision) {
+            return null;
+        }
+        const decision = pendingDecision.status === 'pending'
+            ? validatedCandidate.issuerId === selfAgentId
+                ? await this.evaluateIssuerProtocolKickoff(msg, normalized, validatedCandidate, pendingDecision)
+                : await this.waitForProtocolKickoffDecision(msg.channel_id, validatedCandidate, pendingDecision.deadlineAt)
+            : pendingDecision;
+        if (!decision || decision.status !== 'start') {
+            return null;
+        }
+        const rounds = this.validateProtocolKickoffRounds(decision.rounds);
+        if (!rounds) {
+            return null;
+        }
+        return {
+            participantIds: decision.participantIds,
+            issuerId: decision.issuerId,
+            maxTurnCount: rounds * 2,
+        };
+    }
+    validateProtocolKickoffRounds(rounds) {
+        if (!Number.isFinite(rounds) ||
+            typeof rounds !== 'number' ||
+            !Number.isInteger(rounds) ||
+            rounds < 1) {
+            return null;
+        }
+        return Math.min(rounds, PROTOCOL_KICKOFF_ROUND_LIMIT);
+    }
+    protocolRequestFromKickoffDecision(decision) {
+        const rounds = this.validateProtocolKickoffRounds(decision.rounds);
+        if (!rounds) {
+            return null;
+        }
+        return {
+            participantIds: decision.participantIds,
+            issuerId: decision.issuerId,
+            maxTurnCount: rounds * 2,
+        };
+    }
+    async evaluateIssuerProtocolKickoff(msg, normalized, protocolCandidate, pendingDecision) {
+        const priorMissedCollaborationDiagnostic = this.resolveMissedCollaborationDiagnosticForTurn(msg.channel_id);
+        const executed = await this.executeTurn(msg, normalized.authorId, normalized.content, {
+            kickoff: protocolCandidate,
+            silent: true,
         });
-        this.progressChannelQueues.set(channelId, next);
-        return next;
+        if (executed.stale) {
+            return null;
+        }
+        this.recordCollaborationOutcome(msg.channel_id, {
+            responseState: executed.completed ? 'responded' : 'failed',
+            deliveryState: executed.deliveryState ?? 'not-delivered',
+        });
+        this.updateMissedCollaborationDiagnostic(msg.channel_id, priorMissedCollaborationDiagnostic);
+        const reply = executed.reply;
+        const rounds = reply?.control?.kind === 'start-protocol'
+            ? this.validateProtocolKickoffRounds(reply.control.rounds)
+            : null;
+        const finalizedDecision = await this.finalizeProtocolKickoffDecision(msg.channel_id, protocolCandidate, pendingDecision.deadlineAt, {
+            status: rounds ? 'start' : 'decline',
+            ...(rounds ? { rounds } : {}),
+        });
+        this.logger.debug('completed silent kickoff evaluation', {
+            channelId: msg.channel_id,
+            messageId: msg.message_id,
+            anchorMessageId: protocolCandidate.anchorMessageId,
+            provider: this.config.agent.provider,
+            agentName: this.config.agent.agentName,
+            controlKind: reply?.control?.kind ?? null,
+            controlMalformed: reply?.controlMalformed ?? false,
+            outcome: rounds ? 'start' : reply?.controlMalformed ? 'malformed-control' : 'no-control',
+            persistedStatus: finalizedDecision?.status ?? null,
+            persistedRounds: finalizedDecision?.rounds ?? null,
+            replyLength: reply ? resolvePublicReplyText(reply).length : 0,
+        });
+        return finalizedDecision;
     }
-    ensureProgressDraft(channelId) {
-        let draft = this.progressDrafts.get(channelId);
-        if (!draft) {
-            draft = new DraftMessageController(this.borgee, channelId, () => !this.controlPlaneClosed);
-            this.progressDrafts.set(channelId, draft);
+    async waitForProtocolKickoffDecision(channelId, protocolCandidate, deadlineAt) {
+        for (;;) {
+            const decision = await this.readProtocolKickoffDecisionRecord(channelId, protocolCandidate.anchorMessageId);
+            if (decision &&
+                this.matchesProtocolKickoffDecisionRecord(channelId, protocolCandidate, decision)) {
+                if (decision.status !== 'pending') {
+                    return decision;
+                }
+                const now = Date.now();
+                if (decision.deadlineAt <= now) {
+                    return null;
+                }
+                await delay(Math.min(PROTOCOL_KICKOFF_DECISION_POLL_INTERVAL_MS, decision.deadlineAt - now));
+                continue;
+            }
+            const now = Date.now();
+            if (deadlineAt <= now) {
+                return null;
+            }
+            await delay(Math.min(PROTOCOL_KICKOFF_DECISION_POLL_INTERVAL_MS, deadlineAt - now));
         }
-        return draft;
     }
-    async ensureSelfAgentId() {
-        if (this.selfAgentId) {
-            return this.selfAgentId;
+    async ensureProtocolKickoffDecisionRecord(channelId, protocolCandidate) {
+        const existing = await this.readProtocolKickoffDecisionRecord(channelId, protocolCandidate.anchorMessageId);
+        if (existing) {
+            return this.matchesProtocolKickoffDecisionRecord(channelId, protocolCandidate, existing)
+                ? existing
+                : null;
         }
-        if (!this.selfAgentIdPromise) {
-            this.selfAgentIdPromise = this.borgee.getMe().then((me) => {
-                this.selfAgentId = me.id;
-                return me.id;
-            }).catch((error) => {
-                this.selfAgentIdPromise = null;
+        const record = {
+            channelId,
+            ...protocolCandidate,
+            deadlineAt: nextProtocolKickoffDecisionDeadline(),
+            status: 'pending',
+        };
+        try {
+            await this.writeProtocolKickoffDecisionRecord(record, 'wx');
+            return record;
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== 'EEXIST') {
                 throw error;
+            }
+        }
+        const persisted = await this.readProtocolKickoffDecisionRecord(channelId, protocolCandidate.anchorMessageId);
+        return persisted &&
+            this.matchesProtocolKickoffDecisionRecord(channelId, protocolCandidate, persisted)
+            ? persisted
+            : null;
+    }
+    async finalizeProtocolKickoffDecision(channelId, protocolCandidate, deadlineAt, decision) {
+        const current = await this.readProtocolKickoffDecisionRecord(channelId, protocolCandidate.anchorMessageId);
+        if (current &&
+            !this.matchesProtocolKickoffDecisionRecord(channelId, protocolCandidate, current)) {
+            return null;
+        }
+        const effectiveDeadlineAt = current?.deadlineAt ?? deadlineAt;
+        if (effectiveDeadlineAt <= Date.now()) {
+            if (!current || current.status === 'pending') {
+                await this.writeProtocolKickoffDecisionRecord({
+                    channelId,
+                    ...protocolCandidate,
+                    deadlineAt: effectiveDeadlineAt,
+                    status: 'decline',
+                    decidedAt: Date.now(),
+                });
+            }
+            return null;
+        }
+        if (current?.status === 'start') {
+            return current;
+        }
+        if (current?.status === 'decline') {
+            return current;
+        }
+        const finalized = {
+            channelId,
+            ...protocolCandidate,
+            deadlineAt: effectiveDeadlineAt,
+            status: decision.status,
+            ...(decision.rounds ? { rounds: decision.rounds } : {}),
+            decidedAt: Date.now(),
+        };
+        await this.writeProtocolKickoffDecisionRecord(finalized);
+        return finalized;
+    }
+    matchesProtocolKickoffDecisionRecord(channelId, protocolCandidate, record) {
+        return (record.channelId === channelId &&
+            record.anchorMessageId === protocolCandidate.anchorMessageId &&
+            record.issuerId === protocolCandidate.issuerId &&
+            record.participantIds[0] === protocolCandidate.participantIds[0] &&
+            record.participantIds[1] === protocolCandidate.participantIds[1]);
+    }
+    resolveProtocolKickoffDecisionPath(channelId, anchorMessageId) {
+        return resolveSharedProtocolKickoffDecisionPath(this.config.stateRootDir, channelId, anchorMessageId);
+    }
+    resolveSharedProtocolStatusPath(channelId, anchorMessageId) {
+        return resolveSharedProtocolStatusPath(this.config.stateRootDir, channelId, anchorMessageId);
+    }
+    async readProtocolKickoffDecisionRecord(channelId, anchorMessageId) {
+        try {
+            const content = await readFile(this.resolveProtocolKickoffDecisionPath(channelId, anchorMessageId), 'utf8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === 'ENOENT') {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async writeProtocolKickoffDecisionRecord(record, flag = 'w') {
+        const path = this.resolveProtocolKickoffDecisionPath(record.channelId, record.anchorMessageId);
+        await writePrivateJsonFile(path, record, { exclusive: flag === 'wx' });
+    }
+    async handleActiveProtocolAnchorReplay(msg, normalized, channelState, protocolState, selfAgentId) {
+        if (protocolState.currentTurnIndex > 0) {
+            return;
+        }
+        if (selfAgentId === protocolState.issuerId) {
+            this.enqueueCollaborationMessage(channelState, {
+                kind: 'protocol-turn',
+                raw: msg,
+                authorId: normalized.authorId,
+                authorKind: 'human',
+                content: normalized.content,
             });
+            await this.ensureCollaborationProcessor(msg.channel_id, channelState);
+            return;
         }
-        return this.selfAgentIdPromise;
+        this.armProtocolFallback(msg.channel_id, channelState, protocolState);
+    }
+    async startProtocolForAnchor(msg, normalized, channelState, protocolRequest, selfAgentId) {
+        this.cancelProtocolState(msg.channel_id, channelState);
+        const protocolState = {
+            ownerAgentId: selfAgentId,
+            anchorAuthorId: normalized.authorId,
+            anchorContent: normalized.content,
+            anchorMessageId: msg.message_id ?? randomUUID(),
+            participantIds: protocolRequest.participantIds,
+            issuerId: protocolRequest.issuerId,
+            expectedNextSpeakerId: protocolRequest.issuerId,
+            currentTurnIndex: 0,
+            maxTurnCount: protocolRequest.maxTurnCount,
+            active: true,
+            finished: false,
+            fallbackDeadlineAt: nextProtocolFallbackDeadline(),
+            fallbackTimer: null,
+        };
+        channelState.protocol = protocolState;
+        channelState.protocolLoaded = true;
+        await this.persistProtocolState(msg.channel_id, protocolState);
+        await this.persistSharedProtocolStatus(msg.channel_id, protocolState);
+        if (selfAgentId === protocolRequest.issuerId) {
+            this.enqueueCollaborationMessage(channelState, {
+                kind: 'protocol-turn',
+                raw: msg,
+                authorId: normalized.authorId,
+                authorKind: 'human',
+                content: normalized.content,
+            });
+            await this.ensureCollaborationProcessor(msg.channel_id, channelState);
+            return;
+        }
+        this.armProtocolFallback(msg.channel_id, channelState, protocolState);
+    }
+    async deliverDeferredTurnReply(channelId, activeTurn, executed) {
+        if (!executed.completed ||
+            executed.stale ||
+            !this.canAcceptTurnOutput(channelId, activeTurn.generation)) {
+            return;
+        }
+        const publicReplyText = executed.publicReplyText ?? '';
+        if (!this.started || this.controlPlaneClosed || !hasVisibleText(publicReplyText)) {
+            return;
+        }
+        const posted = await this.borgee.postMessage({
+            channelId,
+            body: executed.visibleReplyBody ?? publicReplyText,
+            replyToId: activeTurn.delivery?.replyToId,
+        });
+        executed.deliveredMessageId = posted.messageId;
+    }
+    async handleActiveProtocolParticipantMessage(msg, normalized, channelState, protocolState, selfAgentId) {
+        if (!msg.message_id || normalized.authorId !== protocolState.expectedNextSpeakerId) {
+            return;
+        }
+        const expectedReplyToId = protocolState.lastProtocolMessageId ?? protocolState.anchorMessageId;
+        const confirmed = await this.confirmProtocolMessage(msg.channel_id, msg.message_id, normalized.authorId, expectedReplyToId, msg.created_at);
+        if (!confirmed) {
+            if (selfAgentId !== protocolState.issuerId) {
+                this.armProtocolFallback(msg.channel_id, channelState, protocolState);
+            }
+            return;
+        }
+        this.clearProtocolFallback(channelState);
+        protocolState.currentTurnIndex += 1;
+        protocolState.lastProtocolMessageId = msg.message_id;
+        const continuesProtocol = msg.type === 'mention' || hasRelayBodyMention(confirmed.body, selfAgentId);
+        if (!continuesProtocol) {
+            protocolState.active = false;
+            protocolState.finished = true;
+            protocolState.expectedNextSpeakerId = normalized.authorId;
+            await this.persistProtocolState(msg.channel_id, protocolState);
+            return;
+        }
+        if (protocolState.currentTurnIndex >= protocolState.maxTurnCount) {
+            protocolState.active = false;
+            protocolState.finished = true;
+            protocolState.expectedNextSpeakerId = normalized.authorId;
+            await this.persistProtocolState(msg.channel_id, protocolState);
+            return;
+        }
+        protocolState.expectedNextSpeakerId = this.otherProtocolParticipant(protocolState, normalized.authorId);
+        protocolState.fallbackDeadlineAt = nextProtocolFallbackDeadline();
+        await this.persistProtocolState(msg.channel_id, protocolState);
+        if (protocolState.expectedNextSpeakerId !== selfAgentId) {
+            if (selfAgentId !== protocolState.issuerId) {
+                this.armProtocolFallback(msg.channel_id, channelState, protocolState);
+            }
+            return;
+        }
+        this.enqueueCollaborationMessage(channelState, {
+            kind: 'protocol-turn',
+            raw: msg,
+            authorId: normalized.authorId,
+            authorKind: 'agent',
+            content: normalized.content,
+        });
+        await this.ensureCollaborationProcessor(msg.channel_id, channelState);
+    }
+    enqueueCollaborationMessage(channelState, message) {
+        channelState.queue.push(message);
+        while (channelState.queue.length > MAX_QUEUED_MESSAGES_PER_CHANNEL) {
+            channelState.queue.shift();
+        }
+    }
+    ensureCollaborationChannelState(channelId) {
+        let state = this.collaborationChannels.get(channelId);
+        if (!state) {
+            state = {
+                generation: 0,
+                queue: [],
+                running: false,
+                protocolLoaded: false,
+                attentionLoaded: false,
+            };
+            this.collaborationChannels.set(channelId, state);
+        }
+        return state;
+    }
+    async ensureCollaborationProcessor(channelId, channelState) {
+        if (channelState.processor) {
+            await channelState.processor;
+            return;
+        }
+        const processor = this.processCollaborationQueue(channelId, channelState).finally(() => {
+            if (channelState.processor === processor) {
+                channelState.processor = undefined;
+            }
+        });
+        channelState.processor = processor;
+        await processor;
+    }
+    async processCollaborationQueue(channelId, channelState) {
+        while (this.started && !this.controlPlaneClosed && !channelState.blocked) {
+            const next = channelState.queue.shift();
+            if (!next) {
+                return;
+            }
+            channelState.running = true;
+            try {
+                await this.runCollaborationTurn(channelId, channelState, next);
+            }
+            finally {
+                channelState.running = false;
+            }
+            if (channelState.blocked) {
+                channelState.queue = channelState.queue.filter((queued) => queued.authorKind !== 'agent');
+                const resumed = await this.tryResumeBlockedFromQueue(channelId, channelState);
+                if (resumed) {
+                    continue;
+                }
+            }
+        }
+    }
+    async tryResumeBlockedFromQueue(channelId, channelState) {
+        const blocked = channelState.blocked;
+        if (!blocked || channelState.queue.length === 0) {
+            return false;
+        }
+        const retained = [];
+        for (const [index, queued] of channelState.queue.entries()) {
+            const classified = queued.authorKind === 'human'
+                ? 'human'
+                : await this.classifyQueuedBlockedWakeCandidate(queued, blocked);
+            if (classified === 'agent') {
+                blocked.suppressedAgentMessages += 1;
+                this.recordBlockedSuppressionOutcome(channelId, channelState);
+                continue;
+            }
+            if (classified === 'unknown') {
+                retained.push(queued);
+                continue;
+            }
+            const wakeBlockedState = blocked.awaitingUser;
+            channelState.blocked = undefined;
+            this.awaitingUserByChannel.delete(channelId);
+            channelState.queue = [
+                {
+                    ...queued,
+                    authorKind: 'human',
+                    wakeBlockedState,
+                },
+                ...channelState.queue.slice(index + 1),
+            ];
+            return true;
+        }
+        channelState.queue = retained;
+        return false;
+    }
+    async runCollaborationTurn(channelId, channelState, message) {
+        if (message.kind === 'protocol-turn') {
+            await this.runProtocolManagedTurn(channelId, channelState, message);
+            return;
+        }
+        const taskThreadContext = await this.buildTurnTaskThreadContext(message.raw, channelId);
+        const attentionSnapshot = this.getAttentionSnapshotForTurn(channelId, taskThreadContext);
+        if (!message.wakeBlockedState
+            && this.isHumanWakeFiltered(message.raw, message.authorKind, attentionSnapshot)) {
+            return;
+        }
+        channelState.generation += 1;
+        const activeTurn = {
+            generation: channelState.generation,
+            turnExecutionId: randomUUID(),
+            superseded: false,
+            collaborationMessagesSent: 0,
+            targetCooldowns: new Map(),
+        };
+        this.clearCollaborationDraft(channelId);
+        channelState.recentTurn = undefined;
+        channelState.activeTurn = activeTurn;
+        const executed = await this.executeTurn(message.raw, message.authorId, this.buildIncomingContent(message), {
+            activeTurn,
+            incomingAuthorKind: message.authorKind,
+            attentionSnapshot,
+            taskThreadContext,
+        });
+        channelState.activeTurn = undefined;
+        if (executed.stale) {
+            return;
+        }
+        if (executed.completed) {
+            await this.commitAttentionSnapshot(channelId, executed.appliedAttentionSnapshot ?? attentionSnapshot);
+            this.rememberRecentTurn(channelState, activeTurn);
+        }
+        if (executed.completed && executed.reply?.awaitingUser) {
+            channelState.blocked = {
+                awaitingUser: executed.reply.awaitingUser,
+                suppressedAgentMessages: 0,
+            };
+            this.awaitingUserByChannel.set(channelId, executed.reply.awaitingUser);
+            this.recordCollaborationOutcome(channelId, {
+                responseState: 'blocked',
+                deliveryState: executed.deliveryState ?? 'not-delivered',
+                wakeState: 'waiting',
+                blockedDetails: {
+                    question: executed.reply.awaitingUser.question,
+                    ...(executed.reply.awaitingUser.reason
+                        ? { reason: executed.reply.awaitingUser.reason }
+                        : {}),
+                },
+                turnExecutionId: activeTurn.turnExecutionId ?? undefined,
+            });
+            return;
+        }
+        if (!executed.completed && message.wakeBlockedState) {
+            const existing = this.collaborationOutcomeByChannel.get(channelId);
+            channelState.blocked = {
+                awaitingUser: message.wakeBlockedState,
+                suppressedAgentMessages: 0,
+            };
+            this.awaitingUserByChannel.set(channelId, message.wakeBlockedState);
+            this.recordCollaborationOutcome(channelId, {
+                responseState: 'blocked',
+                deliveryState: existing?.responseState === 'blocked' ? existing.deliveryState : 'not-delivered',
+                wakeState: 'waiting',
+                blockedDetails: {
+                    question: message.wakeBlockedState.question,
+                    ...(message.wakeBlockedState.reason
+                        ? { reason: message.wakeBlockedState.reason }
+                        : {}),
+                },
+                ...(existing?.turnExecutionId ? { turnExecutionId: existing.turnExecutionId } : {}),
+            });
+            return;
+        }
+        channelState.blocked = undefined;
+        this.awaitingUserByChannel.delete(channelId);
+        this.recordCollaborationOutcome(channelId, {
+            responseState: executed.completed ? 'responded' : 'failed',
+            deliveryState: executed.deliveryState ?? 'not-delivered',
+            ...(message.wakeBlockedState ? { wakeState: 'resumed-human' } : {}),
+            turnExecutionId: activeTurn.turnExecutionId ?? undefined,
+        });
+    }
+    async runProtocolManagedTurn(channelId, channelState, message) {
+        const protocolState = channelState.protocol;
+        const selfAgentId = await this.ensureSelfAgentId();
+        if (!protocolState?.active || protocolState.expectedNextSpeakerId !== selfAgentId) {
+            return;
+        }
+        if (!(await this.canContinueSharedProtocol(channelId, channelState, protocolState))) {
+            return;
+        }
+        channelState.generation += 1;
+        const currentTurnIndex = protocolState.currentTurnIndex + 1;
+        const peerId = this.otherProtocolParticipant(protocolState, selfAgentId);
+        const isFinalTurn = currentTurnIndex >= protocolState.maxTurnCount;
+        const taskThreadContext = message.taskThreadContext
+            ?? await this.buildTurnTaskThreadContext(message.raw, channelId);
+        const attentionSnapshot = message.attentionSnapshot
+            ?? this.getAttentionSnapshotForTurn(channelId, taskThreadContext);
+        const activeTurn = {
+            generation: channelState.generation,
+            turnExecutionId: randomUUID(),
+            superseded: false,
+            collaborationMessagesSent: 0,
+            targetCooldowns: new Map(),
+            delivery: {
+                replyToId: protocolState.lastProtocolMessageId ?? protocolState.anchorMessageId,
+            },
+            protocol: {
+                anchorMessageId: protocolState.anchorMessageId,
+                anchorSummary: summarizeAnchorContent(protocolState.anchorContent),
+                issuerId: protocolState.issuerId,
+                role: protocolState.currentTurnIndex === 0 ? 'issuer' : isFinalTurn ? 'final' : 'intermediate',
+                targetPeerId: peerId,
+                turnIndex: currentTurnIndex,
+                maxTurnCount: protocolState.maxTurnCount,
+            },
+        };
+        this.clearCollaborationDraft(channelId);
+        channelState.recentTurn = undefined;
+        channelState.activeTurn = activeTurn;
+        const executed = await this.executeTurn(message.raw, message.authorId, this.buildIncomingContent(message), {
+            activeTurn,
+            incomingAuthorKind: message.authorKind,
+            attentionSnapshot,
+            taskThreadContext,
+        });
+        channelState.activeTurn = undefined;
+        if (executed.stale || !protocolState.active) {
+            return;
+        }
+        if (executed.completed) {
+            await this.commitAttentionSnapshot(channelId, executed.appliedAttentionSnapshot ?? attentionSnapshot);
+            this.rememberRecentTurn(channelState, activeTurn);
+        }
+        const deliveredMessageId = executed.deliveredMessageId ?? null;
+        const visibleMessageId = deliveredMessageId ?? protocolState.lastProtocolMessageId;
+        if (executed.reply?.controlMalformed) {
+            this.recordCollaborationOutcome(channelId, {
+                responseState: executed.completed ? 'responded' : 'failed',
+                deliveryState: executed.deliveryState ?? 'not-delivered',
+                ...(message.wakeBlockedState ? { wakeState: 'resumed-human' } : {}),
+                turnExecutionId: activeTurn.turnExecutionId ?? undefined,
+            });
+            this.finishProtocolState(channelId, channelState, protocolState, visibleMessageId);
+            return;
+        }
+        if (!executed.reply?.control) {
+            this.recordCollaborationOutcome(channelId, {
+                responseState: executed.completed ? 'responded' : 'failed',
+                deliveryState: executed.deliveryState ?? 'not-delivered',
+                ...(message.wakeBlockedState ? { wakeState: 'resumed-human' } : {}),
+                turnExecutionId: activeTurn.turnExecutionId ?? undefined,
+            });
+            this.finishProtocolState(channelId, channelState, protocolState, visibleMessageId);
+            return;
+        }
+        if (executed.completed && executed.reply.control.kind === 'awaiting-user') {
+            channelState.blocked = {
+                awaitingUser: executed.reply.awaitingUser ?? {
+                    question: executed.reply.control.question,
+                    ...(executed.reply.control.reason ? { reason: executed.reply.control.reason } : {}),
+                },
+                suppressedAgentMessages: 0,
+            };
+            this.awaitingUserByChannel.set(channelId, channelState.blocked.awaitingUser);
+            this.recordCollaborationOutcome(channelId, {
+                responseState: 'blocked',
+                deliveryState: executed.deliveryState ?? 'not-delivered',
+                wakeState: 'waiting',
+                blockedDetails: {
+                    question: channelState.blocked.awaitingUser.question,
+                    ...(channelState.blocked.awaitingUser.reason
+                        ? { reason: channelState.blocked.awaitingUser.reason }
+                        : {}),
+                },
+                turnExecutionId: activeTurn.turnExecutionId ?? undefined,
+            });
+            this.finishProtocolState(channelId, channelState, protocolState, visibleMessageId);
+            return;
+        }
+        if (executed.reply.control.kind === 'start-protocol') {
+            this.recordCollaborationOutcome(channelId, {
+                responseState: executed.completed ? 'responded' : 'failed',
+                deliveryState: executed.deliveryState ?? 'not-delivered',
+                ...(message.wakeBlockedState ? { wakeState: 'resumed-human' } : {}),
+                turnExecutionId: activeTurn.turnExecutionId ?? undefined,
+            });
+            this.updateMissedCollaborationDiagnostic(channelId, undefined);
+            this.finishProtocolState(channelId, channelState, protocolState, visibleMessageId);
+            return;
+        }
+        if (executed.reply.control.kind === 'attention-only') {
+            this.recordCollaborationOutcome(channelId, {
+                responseState: executed.completed ? 'responded' : 'failed',
+                deliveryState: executed.deliveryState ?? 'not-delivered',
+                ...(message.wakeBlockedState ? { wakeState: 'resumed-human' } : {}),
+                turnExecutionId: activeTurn.turnExecutionId ?? undefined,
+            });
+            this.updateMissedCollaborationDiagnostic(channelId, undefined);
+            this.finishProtocolState(channelId, channelState, protocolState, visibleMessageId);
+            return;
+        }
+        if (!deliveredMessageId) {
+            this.finishProtocolState(channelId, channelState, protocolState);
+            this.awaitingUserByChannel.delete(channelId);
+            channelState.blocked = undefined;
+            this.recordCollaborationOutcome(channelId, {
+                responseState: 'failed',
+                deliveryState: executed.deliveryState ?? 'not-delivered',
+                ...(message.wakeBlockedState ? { wakeState: 'resumed-human' } : {}),
+                turnExecutionId: activeTurn.turnExecutionId ?? undefined,
+            });
+            return;
+        }
+        protocolState.currentTurnIndex = currentTurnIndex;
+        if (deliveredMessageId) {
+            protocolState.lastProtocolMessageId = deliveredMessageId;
+        }
+        if (executed.reply.control.kind === 'conclude-locally') {
+            this.finishProtocolState(channelId, channelState, protocolState, visibleMessageId);
+            this.awaitingUserByChannel.delete(channelId);
+            channelState.blocked = undefined;
+            this.recordCollaborationOutcome(channelId, {
+                responseState: 'responded',
+                deliveryState: executed.deliveryState ?? 'not-delivered',
+                ...(message.wakeBlockedState ? { wakeState: 'resumed-human' } : {}),
+                turnExecutionId: activeTurn.turnExecutionId ?? undefined,
+            });
+            return;
+        }
+        if (currentTurnIndex >= protocolState.maxTurnCount) {
+            this.finishProtocolState(channelId, channelState, protocolState, visibleMessageId);
+            this.awaitingUserByChannel.delete(channelId);
+            channelState.blocked = undefined;
+            this.recordCollaborationOutcome(channelId, {
+                responseState: 'responded',
+                deliveryState: executed.deliveryState ?? 'not-delivered',
+                ...(message.wakeBlockedState ? { wakeState: 'resumed-human' } : {}),
+                turnExecutionId: activeTurn.turnExecutionId ?? undefined,
+            });
+            return;
+        }
+        protocolState.expectedNextSpeakerId = peerId;
+        protocolState.fallbackDeadlineAt = nextProtocolFallbackDeadline();
+        await this.persistProtocolState(channelId, protocolState);
+        if (selfAgentId !== protocolState.issuerId) {
+            this.armProtocolFallback(channelId, channelState, protocolState);
+        }
+        channelState.blocked = undefined;
+        this.awaitingUserByChannel.delete(channelId);
+        this.recordCollaborationOutcome(channelId, {
+            responseState: 'responded',
+            deliveryState: executed.deliveryState ?? 'not-delivered',
+            ...(message.wakeBlockedState ? { wakeState: 'resumed-human' } : {}),
+            turnExecutionId: activeTurn.turnExecutionId ?? undefined,
+        });
+    }
+    buildIncomingContent(message) {
+        if (!message.wakeBlockedState) {
+            return message.content;
+        }
+        const lines = [
+            '[Internal note: a previously blocked human reply has arrived.]',
+            `Pending question: ${message.wakeBlockedState.question}`,
+            ...(message.wakeBlockedState.reason
+                ? [`Blocked reason: ${message.wakeBlockedState.reason}`]
+                : []),
+            `Human reply from ${message.authorId}: ${message.content}`,
+            '',
+            message.content,
+        ];
+        return lines.join('\n');
+    }
+    otherProtocolParticipant(protocolState, currentAgentId) {
+        return protocolState.participantIds[0] === currentAgentId
+            ? protocolState.participantIds[1]
+            : protocolState.participantIds[0];
+    }
+    resolveProtocolStatePath(channelId, ownerAgentId) {
+        return resolve(this.config.stateRootDir, PROTOCOL_STATE_DIRNAME, `${encodeStatePathSegment(channelId)}--${encodeStatePathSegment(ownerAgentId)}.json`);
+    }
+    async ensureProtocolStateLoaded(channelId, channelState) {
+        if (channelState.protocolLoaded) {
+            return;
+        }
+        if (channelState.protocol) {
+            channelState.protocolLoaded = true;
+            return;
+        }
+        channelState.protocolLoaded = true;
+        try {
+            const selfAgentId = await this.ensureSelfAgentId();
+            const content = await readFile(this.resolveProtocolStatePath(channelId, selfAgentId), 'utf8');
+            const parsed = JSON.parse(content);
+            if ((parsed.ownerAgentId && parsed.ownerAgentId !== selfAgentId) ||
+                !parsed.participantIds.includes(selfAgentId)) {
+                return;
+            }
+            const resolvedProtocolState = await this.reconcileOwnProtocolStateFromPeers(channelId, {
+                ...parsed,
+                ownerAgentId: parsed.ownerAgentId ?? selfAgentId,
+            }, selfAgentId);
+            channelState.protocol = {
+                ...resolvedProtocolState,
+                fallbackTimer: null,
+            };
+            if (resolvedProtocolState.currentTurnIndex !== parsed.currentTurnIndex ||
+                resolvedProtocolState.expectedNextSpeakerId !== parsed.expectedNextSpeakerId ||
+                resolvedProtocolState.active !== parsed.active ||
+                resolvedProtocolState.finished !== parsed.finished ||
+                resolvedProtocolState.lastProtocolMessageId !== parsed.lastProtocolMessageId) {
+                await this.persistProtocolState(channelId, channelState.protocol);
+            }
+            if (resolvedProtocolState.active) {
+                this.armProtocolFallback(channelId, channelState, channelState.protocol);
+            }
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== 'ENOENT') {
+                this.logger.error('failed to load protocol state', {
+                    channelId,
+                    error: summarizeError(error),
+                });
+            }
+        }
+    }
+    async reconcileOwnProtocolStateFromPeers(channelId, protocolState, selfAgentId) {
+        const directoryPath = join(this.config.stateRootDir, PROTOCOL_STATE_DIRNAME);
+        const channelPrefix = `${encodeStatePathSegment(channelId)}--`;
+        const ownSuffix = `--${encodeStatePathSegment(selfAgentId)}.json`;
+        let entries;
+        try {
+            entries = await readdir(directoryPath);
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === 'ENOENT') {
+                return protocolState;
+            }
+            throw error;
+        }
+        let resolved = protocolState;
+        for (const entry of entries) {
+            if (!entry.startsWith(channelPrefix) || entry.endsWith(ownSuffix)) {
+                continue;
+            }
+            try {
+                const candidate = JSON.parse(await readFile(join(directoryPath, entry), 'utf8'));
+                if (!candidate.participantIds.includes(selfAgentId)) {
+                    continue;
+                }
+                if (!shouldAdoptPeerProtocolState(resolved, candidate, selfAgentId)) {
+                    continue;
+                }
+                resolved = {
+                    ...candidate,
+                    ownerAgentId: selfAgentId,
+                };
+            }
+            catch (error) {
+                const code = error.code;
+                if (code === 'ENOENT') {
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return resolved;
+    }
+    async loadPersistedProtocolStates() {
+        if (!this.collaborationEnabled) {
+            return;
+        }
+        const selfAgentId = await this.ensureSelfAgentId();
+        const ownSuffix = `--${encodeStatePathSegment(selfAgentId)}.json`;
+        const directoryPath = join(this.config.stateRootDir, PROTOCOL_STATE_DIRNAME);
+        let entries;
+        try {
+            entries = await readdir(directoryPath);
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== 'ENOENT') {
+                this.logger.error('failed to enumerate protocol state directory', {
+                    directoryPath,
+                    error: summarizeError(error),
+                });
+            }
+            return;
+        }
+        for (const entry of entries) {
+            if (!entry.endsWith(ownSuffix)) {
+                continue;
+            }
+            const encodedChannelId = entry.slice(0, -ownSuffix.length);
+            const channelId = decodeStatePathSegment(encodedChannelId);
+            if (channelId == null) {
+                continue;
+            }
+            const channelState = this.ensureCollaborationChannelState(channelId);
+            await this.ensureProtocolStateLoaded(channelId, channelState);
+        }
+    }
+    async resumeOwnedProtocolTurns() {
+        if (!this.collaborationEnabled) {
+            return;
+        }
+        const selfAgentId = await this.ensureSelfAgentId();
+        for (const [channelId, channelState] of this.collaborationChannels.entries()) {
+            const protocolState = channelState.protocol;
+            if (!protocolState?.active || protocolState.expectedNextSpeakerId !== selfAgentId) {
+                continue;
+            }
+            if (channelState.activeTurn ||
+                channelState.queue.some((message) => message.kind === 'protocol-turn')) {
+                continue;
+            }
+            const resumed = await this.buildResumedProtocolMessage(channelId, protocolState);
+            if (!resumed) {
+                this.cancelProtocolState(channelId, channelState);
+                continue;
+            }
+            this.enqueueCollaborationMessage(channelState, resumed);
+            await this.ensureCollaborationProcessor(channelId, channelState);
+        }
+    }
+    async buildResumedProtocolMessage(channelId, protocolState) {
+        if (protocolState.currentTurnIndex === 0) {
+            return {
+                kind: 'protocol-turn',
+                raw: {
+                    channel_id: channelId,
+                    message_id: protocolState.anchorMessageId,
+                    user_id: protocolState.anchorAuthorId,
+                    content: protocolState.anchorContent,
+                    body: protocolState.anchorContent,
+                    type: 'message',
+                },
+                authorId: protocolState.anchorAuthorId,
+                authorKind: 'human',
+                content: protocolState.anchorContent,
+            };
+        }
+        if (!protocolState.lastProtocolMessageId) {
+            return null;
+        }
+        let before;
+        for (;;) {
+            const history = await this.borgee.readChannelHistory({
+                channelId,
+                before,
+                limit: 200,
+            });
+            const priorMessage = history.find((entry) => entry.id === protocolState.lastProtocolMessageId);
+            if (priorMessage) {
+                return {
+                    kind: 'protocol-turn',
+                    raw: {
+                        channel_id: channelId,
+                        message_id: priorMessage.id,
+                        user_id: priorMessage.authorId,
+                        content: priorMessage.body,
+                        body: priorMessage.body,
+                        type: 'message',
+                        created_at: priorMessage.createdAt,
+                    },
+                    authorId: priorMessage.authorId,
+                    authorKind: 'agent',
+                    content: priorMessage.body,
+                };
+            }
+            if (history.length < 200) {
+                break;
+            }
+            const oldestCreatedAt = history.reduce((oldest, entry) => {
+                return oldest == null || entry.createdAt < oldest ? entry.createdAt : oldest;
+            }, null);
+            if (oldestCreatedAt == null || (before != null && oldestCreatedAt >= before)) {
+                break;
+            }
+            before = oldestCreatedAt;
+        }
+        return null;
+    }
+    async persistProtocolState(channelId, protocolState) {
+        const ownerAgentId = protocolState.ownerAgentId ?? (await this.ensureSelfAgentId());
+        protocolState.ownerAgentId = ownerAgentId;
+        await writePrivateJsonFile(this.resolveProtocolStatePath(channelId, ownerAgentId), {
+            ownerAgentId,
+            anchorAuthorId: protocolState.anchorAuthorId,
+            anchorContent: protocolState.anchorContent,
+            anchorMessageId: protocolState.anchorMessageId,
+            participantIds: protocolState.participantIds,
+            issuerId: protocolState.issuerId,
+            expectedNextSpeakerId: protocolState.expectedNextSpeakerId,
+            currentTurnIndex: protocolState.currentTurnIndex,
+            maxTurnCount: protocolState.maxTurnCount,
+            lastProtocolMessageId: protocolState.lastProtocolMessageId,
+            active: protocolState.active,
+            finished: protocolState.finished,
+            fallbackDeadlineAt: protocolState.fallbackDeadlineAt,
+        });
+    }
+    async persistSharedProtocolStatus(channelId, protocolState) {
+        await writePrivateJsonFile(this.resolveSharedProtocolStatusPath(channelId, protocolState.anchorMessageId), {
+            channelId,
+            anchorMessageId: protocolState.anchorMessageId,
+            active: protocolState.active,
+            finished: protocolState.finished,
+            updatedAt: Date.now(),
+        });
+    }
+    async readSharedProtocolStatus(channelId, anchorMessageId) {
+        try {
+            const content = await readFile(this.resolveSharedProtocolStatusPath(channelId, anchorMessageId), 'utf8');
+            const parsed = JSON.parse(content);
+            if (typeof parsed.active !== 'boolean' || typeof parsed.finished !== 'boolean') {
+                return null;
+            }
+            return { active: parsed.active, finished: parsed.finished };
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === 'ENOENT') {
+                return null;
+            }
+            throw error;
+        }
+    }
+    clearProtocolFallback(channelState) {
+        const timer = channelState?.protocol?.fallbackTimer;
+        if (timer) {
+            clearTimeout(timer);
+            if (channelState?.protocol) {
+                channelState.protocol.fallbackTimer = null;
+            }
+        }
+    }
+    armProtocolFallback(channelId, channelState, protocolState) {
+        this.clearProtocolFallback(channelState);
+        const delay = Math.max(0, protocolState.fallbackDeadlineAt - Date.now());
+        protocolState.fallbackTimer = setTimeout(() => {
+            void this.runProtocolFallback(channelId).catch((error) => {
+                this.logger.error('protocol fallback failed', {
+                    channelId,
+                    error: summarizeError(error),
+                });
+            });
+        }, delay);
+    }
+    async runProtocolFallback(channelId) {
+        const channelState = this.collaborationChannels.get(channelId);
+        const protocolState = channelState?.protocol;
+        const selfAgentId = await this.ensureSelfAgentId();
+        if (!channelState ||
+            !protocolState?.active ||
+            selfAgentId === protocolState.issuerId ||
+            protocolState.expectedNextSpeakerId !== protocolState.issuerId ||
+            protocolState.fallbackDeadlineAt > Date.now()) {
+            return;
+        }
+        await this.handleProtocolFallbackFailure(channelId, channelState, protocolState, selfAgentId);
+    }
+    async handleProtocolFallbackFailure(channelId, channelState, protocolState, selfAgentId) {
+        if (selfAgentId === protocolState.issuerId) {
+            protocolState.fallbackDeadlineAt = nextProtocolFallbackDeadline();
+            await this.persistProtocolState(channelId, protocolState);
+            return;
+        }
+        const fallbackMessage = {
+            channel_id: channelId,
+            message_id: protocolState.anchorMessageId,
+            user_id: protocolState.anchorAuthorId,
+            content: protocolState.anchorContent,
+            body: protocolState.anchorContent,
+            type: 'message',
+        };
+        this.cancelProtocolState(channelId, channelState);
+        const taskThreadContext = await this.buildTurnTaskThreadContext(fallbackMessage, channelId);
+        const attentionSnapshot = this.getAttentionSnapshotForTurn(channelId, taskThreadContext);
+        await this.runUngatedTurn(fallbackMessage, protocolState.anchorAuthorId, protocolState.anchorContent, taskThreadContext, attentionSnapshot);
+    }
+    finishProtocolState(channelId, channelState, protocolState, lastMessageId) {
+        protocolState.active = false;
+        protocolState.finished = true;
+        if (lastMessageId) {
+            protocolState.lastProtocolMessageId = lastMessageId;
+        }
+        this.clearProtocolFallback(channelState);
+        void this.persistProtocolState(channelId, protocolState);
+        void this.persistSharedProtocolStatus(channelId, protocolState);
+    }
+    cancelProtocolState(channelId, channelState) {
+        if (channelState.activeTurn) {
+            this.supersedeActiveTurn(channelId, channelState.activeTurn);
+        }
+        if (!channelState.protocol) {
+            return;
+        }
+        channelState.protocol.active = false;
+        channelState.protocol.finished = false;
+        this.clearProtocolFallback(channelState);
+        void this.persistProtocolState(channelId, channelState.protocol);
+        void this.persistSharedProtocolStatus(channelId, channelState.protocol);
+    }
+    async confirmProtocolMessage(channelId, messageId, authorId, expectedReplyToId, createdAt) {
+        const history = await this.borgee.readChannelHistory({
+            channelId,
+            before: createdAt != null ? createdAt + 1 : undefined,
+            limit: 20,
+        });
+        const matched = history.find((entry) => entry.id === messageId);
+        if (!matched) {
+            return null;
+        }
+        if (matched.authorId !== authorId || matched.replyToId !== expectedReplyToId) {
+            return null;
+        }
+        return matched;
+    }
+    resolveAttentionStatePath(channelId) {
+        return resolveAttentionStatePath(this.config.stateRootDir, channelId);
+    }
+    buildDefaultAttentionSnapshot(options) {
+        return buildNormalizedAttentionSnapshot({
+            observedAt: options?.observedAt,
+            turnExecutionId: options?.turnExecutionId,
+        });
+    }
+    async buildTurnTaskThreadContext(msg, channelId) {
+        if (msg.message_type === 'task_assignment') {
+            const currentTaskId = extractTaskIdFromTaskAssignmentContent(String(msg.content ?? msg.body ?? ''));
+            return currentTaskId ? { state: 'active', currentTaskId } : { state: 'active' };
+        }
+        if (!this.contextInjectionEnabled) {
+            return { state: 'inactive' };
+        }
+        try {
+            const content = await readFile(resolveChannelContextPayloadPath(this.config.stateRootDir, channelId), 'utf8');
+            const payload = JSON.parse(content);
+            if (payload.taskAssignmentContext?.active !== true) {
+                return { state: 'inactive' };
+            }
+            const currentTaskId = typeof payload.taskAssignmentContext.currentTaskId === 'string'
+                ? payload.taskAssignmentContext.currentTaskId.trim()
+                : '';
+            return currentTaskId ? { state: 'active', currentTaskId } : { state: 'active' };
+        }
+        catch {
+            return { state: 'unavailable' };
+        }
+    }
+    async ensureAttentionSnapshotLoaded(channelId, channelState) {
+        if (!this.attentionFollowSemanticsEnabled) {
+            return;
+        }
+        if (channelState?.attentionLoaded) {
+            return;
+        }
+        if (channelState) {
+            channelState.attentionLoaded = true;
+        }
+        try {
+            const content = await readFile(this.resolveAttentionStatePath(channelId), 'utf8');
+            this.attentionSnapshotByChannel.set(channelId, parsePersistedAttentionSnapshot(JSON.parse(content)));
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== 'ENOENT') {
+                this.logger.error('failed to load attention state', {
+                    channelId,
+                    error: summarizeError(error),
+                });
+            }
+            this.attentionSnapshotByChannel.set(channelId, this.buildDefaultAttentionSnapshot());
+        }
+    }
+    revalidateAttentionSnapshotForTurn(channelId, taskThreadContext, options) {
+        const current = this.attentionSnapshotByChannel.get(channelId)
+            ?? this.buildDefaultAttentionSnapshot();
+        if (current.claimContext?.scope !== 'task-thread') {
+            return current;
+        }
+        if (!this.contextInjectionEnabled) {
+            const next = this.buildDefaultAttentionSnapshot({
+                observedAt: options?.observedAt ?? Date.now(),
+                turnExecutionId: options?.turnExecutionId,
+            });
+            this.attentionSnapshotByChannel.set(channelId, next);
+            return next;
+        }
+        if (taskThreadContext.state === 'active' &&
+            taskThreadContext.currentTaskId &&
+            taskThreadContext.currentTaskId === current.claimContext.taskId) {
+            const next = buildNormalizedAttentionSnapshot({
+                ...current,
+                deliveryMode: 'follow',
+                claimState: 'claimed',
+                claimActivation: 'active',
+                observedAt: options?.observedAt ?? Date.now(),
+                turnExecutionId: options?.turnExecutionId,
+                claimContext: current.claimContext,
+            });
+            this.attentionSnapshotByChannel.set(channelId, next);
+            return next;
+        }
+        if (taskThreadContext.state === 'unavailable') {
+            const next = buildNormalizedAttentionSnapshot({
+                ...current,
+                deliveryMode: 'default',
+                claimState: 'claimed',
+                claimActivation: 'dormant',
+                observedAt: options?.observedAt ?? Date.now(),
+                turnExecutionId: options?.turnExecutionId,
+                claimContext: current.claimContext,
+            });
+            this.attentionSnapshotByChannel.set(channelId, next);
+            return next;
+        }
+        const next = this.buildDefaultAttentionSnapshot({
+            observedAt: options?.observedAt ?? Date.now(),
+            turnExecutionId: options?.turnExecutionId,
+        });
+        this.attentionSnapshotByChannel.set(channelId, next);
+        return next;
+    }
+    getAttentionSnapshotForTurn(channelId, taskThreadContext, options) {
+        if (!this.attentionFollowSemanticsEnabled) {
+            return undefined;
+        }
+        return this.revalidateAttentionSnapshotForTurn(channelId, taskThreadContext, options);
+    }
+    isHumanWakeFiltered(msg, authorKind, attentionSnapshot) {
+        if (!this.attentionFollowSemanticsEnabled || authorKind === 'agent') {
+            return false;
+        }
+        if (msg.message_type === 'task_assignment') {
+            return false;
+        }
+        if (this.awaitingUserByChannel.has(msg.channel_id)) {
+            return false;
+        }
+        if (msg.type?.trim() === 'mention') {
+            return false;
+        }
+        const eventKind = msg.type?.trim() ?? '';
+        if (!ORDINARY_HUMAN_EVENT_KINDS.has(eventKind)) {
+            return false;
+        }
+        if (attentionSnapshot?.wakeMode === 'follow-visible-human') {
+            return false;
+        }
+        this.noteWakeSuppressedAttentionPolicy(msg, authorKind);
+        return true;
+    }
+    applyAttentionUpdate(channelId, baseSnapshot, attentionUpdate, taskThreadContext, options) {
+        if (!this.attentionFollowSemanticsEnabled) {
+            return undefined;
+        }
+        if (!attentionUpdate) {
+            return baseSnapshot ?? this.attentionSnapshotByChannel.get(channelId);
+        }
+        const observedAt = options?.observedAt ?? Date.now();
+        const turnExecutionId = options?.turnExecutionId;
+        const current = baseSnapshot
+            ?? this.attentionSnapshotByChannel.get(channelId)
+            ?? this.buildDefaultAttentionSnapshot();
+        const clearClaim = (deliveryMode) => buildNormalizedAttentionSnapshot({
+            deliveryMode,
+            claimState: 'unclaimed',
+            claimActivation: 'inactive',
+            observedAt,
+            turnExecutionId,
+        });
+        switch (attentionUpdate) {
+            case 'follow-channel':
+                return clearClaim('follow');
+            case 'unfollow-channel':
+                return clearClaim('default');
+            case 'mute-channel':
+                return clearClaim('muted');
+            case 'claim-channel':
+                return buildNormalizedAttentionSnapshot({
+                    deliveryMode: 'follow',
+                    claimState: 'claimed',
+                    claimActivation: 'active',
+                    observedAt,
+                    turnExecutionId,
+                });
+            case 'claim-task-thread':
+                if (!this.contextInjectionEnabled
+                    || taskThreadContext.state !== 'active'
+                    || !taskThreadContext.currentTaskId) {
+                    return current;
+                }
+                return buildNormalizedAttentionSnapshot({
+                    deliveryMode: 'follow',
+                    claimState: 'claimed',
+                    claimActivation: 'active',
+                    observedAt,
+                    turnExecutionId,
+                    claimContext: {
+                        scope: 'task-thread',
+                        taskId: taskThreadContext.currentTaskId,
+                    },
+                });
+            case 'unclaim-channel':
+                return buildNormalizedAttentionSnapshot({
+                    deliveryMode: current.deliveryMode,
+                    claimState: 'unclaimed',
+                    claimActivation: 'inactive',
+                    observedAt,
+                    turnExecutionId,
+                });
+            case 'unclaim-task-thread':
+                if (!this.contextInjectionEnabled
+                    || current.claimContext?.scope !== 'task-thread'
+                    || taskThreadContext.state !== 'active'
+                    || !taskThreadContext.currentTaskId
+                    || taskThreadContext.currentTaskId !== current.claimContext.taskId) {
+                    return current;
+                }
+                return buildNormalizedAttentionSnapshot({
+                    deliveryMode: current.deliveryMode,
+                    claimState: 'unclaimed',
+                    claimActivation: 'inactive',
+                    observedAt,
+                    turnExecutionId,
+                });
+            default:
+                return current;
+        }
+    }
+    async commitAttentionSnapshot(channelId, snapshot) {
+        if (!this.attentionFollowSemanticsEnabled || !snapshot) {
+            return;
+        }
+        this.attentionSnapshotByChannel.set(channelId, snapshot);
+        await writePrivateJsonFile(this.resolveAttentionStatePath(channelId), snapshot);
+    }
+    resolveTaskThreadCollaborationContractForTurn(msg, taskThreadContext) {
+        if (!this.taskThreadCollaborationContractEnabled) {
+            return undefined;
+        }
+        return projectTaskThreadCollaborationContract({
+            incomingMessageType: msg.message_type,
+            taskThreadContextActive: taskThreadContext.state === 'active',
+        });
+    }
+    resolveCollaborationCapabilityDeclarationForTurn() {
+        if (!this.collaborationCapabilitiesDiagnosticsEnabled) {
+            return undefined;
+        }
+        return {
+            ...(this.collaborationOutcomeModelEnabled ? { collaborationOutcome: true } : {}),
+            ...(this.attentionFollowSemanticsEnabled ? { attentionSnapshot: true } : {}),
+            ...(this.taskThreadCollaborationContractEnabled
+                ? { taskThreadCollaborationContract: true }
+                : {}),
+            missedCollaborationDiagnostic: true,
+            recoveryExplanation: 'runtime-local-only',
+        };
+    }
+    resolveMissedCollaborationDiagnosticForTurn(channelId) {
+        if (!this.collaborationCapabilitiesDiagnosticsEnabled) {
+            return undefined;
+        }
+        return this.missedCollaborationDiagnosticByChannel.get(channelId);
+    }
+    updateMissedCollaborationDiagnostic(channelId, diagnostic) {
+        if (!this.collaborationCapabilitiesDiagnosticsEnabled || !diagnostic) {
+            this.missedCollaborationDiagnosticByChannel.delete(channelId);
+            return;
+        }
+        this.missedCollaborationDiagnosticByChannel.set(channelId, diagnostic);
+    }
+    noteWakeSuppressedAttentionPolicy(msg, authorKind) {
+        if (authorKind === 'agent' || msg.message_type === 'task_assignment') {
+            return;
+        }
+        const eventKind = msg.type?.trim() ?? '';
+        if (msg.type?.trim() === 'mention' || !ORDINARY_HUMAN_EVENT_KINDS.has(eventKind)) {
+            return;
+        }
+        this.updateMissedCollaborationDiagnostic(msg.channel_id, {
+            stage: 'wake',
+            reason: 'wake-suppressed-attention-policy',
+        });
+    }
+    async runUngatedTurn(msg, authorId, content, taskThreadContext, attentionSnapshot) {
+        const executed = await this.executeTurn(msg, authorId, content, {
+            attentionSnapshot,
+            taskThreadContext,
+        });
+        if (executed.completed && executed.reply) {
+            this.updateAwaitingUserState(msg.channel_id, executed.reply.awaitingUser);
+        }
+        if (executed.completed) {
+            await this.commitAttentionSnapshot(msg.channel_id, executed.appliedAttentionSnapshot ?? attentionSnapshot);
+        }
+        if (!executed.completed) {
+            const awaitingUser = this.awaitingUserByChannel.get(msg.channel_id);
+            if (awaitingUser) {
+                const existing = this.collaborationOutcomeByChannel.get(msg.channel_id);
+                this.recordCollaborationOutcome(msg.channel_id, {
+                    responseState: 'blocked',
+                    deliveryState: existing?.responseState === 'blocked' ? existing.deliveryState : 'not-delivered',
+                    wakeState: 'waiting',
+                    blockedDetails: {
+                        question: awaitingUser.question,
+                        ...(awaitingUser.reason ? { reason: awaitingUser.reason } : {}),
+                    },
+                    ...(existing?.turnExecutionId ? { turnExecutionId: existing.turnExecutionId } : {}),
+                });
+                return;
+            }
+        }
+        this.recordCollaborationOutcome(msg.channel_id, {
+            responseState: executed.completed && executed.reply?.awaitingUser
+                ? 'blocked'
+                : executed.completed
+                    ? 'responded'
+                    : 'failed',
+            deliveryState: executed.deliveryState ?? 'not-delivered',
+            ...(executed.completed && executed.reply?.awaitingUser
+                ? {
+                    wakeState: 'waiting',
+                    blockedDetails: {
+                        question: executed.reply.awaitingUser.question,
+                        ...(executed.reply.awaitingUser.reason
+                            ? { reason: executed.reply.awaitingUser.reason }
+                            : {}),
+                    },
+                }
+                : {}),
+        });
+    }
+    async executeTurn(msg, authorId, content, options) {
+        const channelId = msg.channel_id;
+        const activeTurn = options?.activeTurn;
+        const attentionSnapshot = options?.attentionSnapshot;
+        const taskThreadContext = options?.taskThreadContext ?? { state: 'inactive' };
+        const silentTurn = options?.silent === true;
+        const deferDelivery = options?.deferDelivery === true;
+        const collaborationTurnMode = activeTurn?.protocol
+            ? 'protocol-managed'
+            : options?.kickoff
+                ? 'silent-kickoff'
+                : undefined;
+        const turnExecutionId = activeTurn?.turnExecutionId ?? null;
+        const stopTyping = silentTurn ? () => { } : this.borgee.startTyping(channelId);
+        const collaborationGrounding = await this.buildCollaborationGrounding(authorId, options?.incomingAuthorKind, activeTurn, options?.kickoff);
+        const usePublicDraftProgress = !silentTurn &&
+            !deferDelivery &&
+            !this.collaborationEnabled &&
+            options?.incomingAuthorKind !== 'agent' &&
+            providerUsesDraftProgress(this.config.agent.provider) &&
+            activeTurn?.protocol === undefined;
+        const usePrivateCollaborationDraftProgress = !silentTurn &&
+            !deferDelivery &&
+            this.collaborationEnabled &&
+            turnExecutionId != null &&
+            providerUsesDraftProgress(this.config.agent.provider) &&
+            activeTurn?.protocol === undefined;
+        const turnContext = {
+            eventType: msg.type,
+            channelId,
+            messageId: msg.message_id,
+            authorId,
+            contentLength: content.length,
+            provider: this.config.agent.provider,
+            agentName: this.config.agent.agentName,
+            generation: activeTurn?.generation,
+        };
+        const turnStartedAt = Date.now();
+        this.logger.debug('starting turn', turnContext);
+        let reply;
+        let publicReplyText;
+        let visibleReplyBody;
+        const taskThreadCollaborationContract = this.resolveTaskThreadCollaborationContractForTurn(msg, taskThreadContext);
+        const collaborationOutcome = this.collaborationOutcomeModelEnabled
+            ? this.collaborationOutcomeByChannel.get(channelId)
+            : undefined;
+        const missedCollaborationDiagnostic = this.resolveMissedCollaborationDiagnosticForTurn(channelId);
+        const collaborationCapabilities = this.resolveCollaborationCapabilityDeclarationForTurn();
+        try {
+            reply = await this.provider.generateReply({
+                agentName: this.config.agent.agentName,
+                provider: this.config.agent.provider,
+                channelId,
+                incomingAuthorId: authorId,
+                incomingContent: content,
+                incomingEventKind: msg.type,
+                incomingMessageType: msg.message_type,
+                collaboration: turnExecutionId || options?.kickoff
+                    ? {
+                        enabled: this.collaborationEnabled,
+                        ...(turnExecutionId ? { turnExecutionId } : {}),
+                        turnMode: collaborationTurnMode ?? 'ordinary',
+                        ...(options?.kickoff ? { kickoff: options.kickoff } : {}),
+                        ...(activeTurn?.protocol ? { protocol: activeTurn.protocol } : {}),
+                        ...(collaborationGrounding ? { grounding: collaborationGrounding } : {}),
+                    }
+                    : undefined,
+                collaborationOutcome,
+                attentionSnapshot,
+                ...(taskThreadCollaborationContract ? { taskThreadCollaborationContract } : {}),
+                ...(collaborationCapabilities ? { collaborationCapabilities } : {}),
+                ...(missedCollaborationDiagnostic ? { missedCollaborationDiagnostic } : {}),
+            }, usePublicDraftProgress || usePrivateCollaborationDraftProgress
+                ? {
+                    onProgress: (update) => {
+                        if (!this.canAcceptTurnOutput(channelId, activeTurn?.generation)) {
+                            return;
+                        }
+                        if (usePublicDraftProgress) {
+                            this.ensureProgressDraft(channelId, activeTurn?.generation, activeTurn?.delivery).update(update.text);
+                            return;
+                        }
+                        this.publishCollaborationDraft(channelId, activeTurn, update.text);
+                    },
+                }
+                : undefined);
+            publicReplyText = resolvePublicReplyText(reply);
+            visibleReplyBody = this.resolveVisibleTurnBody(activeTurn, reply, publicReplyText);
+            const appliedAttentionSnapshot = this.applyAttentionUpdate(channelId, attentionSnapshot, reply.controlMalformed
+                ? undefined
+                : (reply.control && 'attentionUpdate' in reply.control
+                    ? reply.control.attentionUpdate
+                    : undefined), taskThreadContext, {
+                observedAt: Date.now(),
+                turnExecutionId: activeTurn?.turnExecutionId ?? undefined,
+            });
+            if (!(await this.canAcceptCompletedTurnOutput(channelId, activeTurn))) {
+                await this.discardDraft(channelId);
+                if (activeTurn?.turnExecutionId) {
+                    this.clearCollaborationDraft(channelId, {
+                        generation: activeTurn.generation,
+                        turnExecutionId: activeTurn.turnExecutionId,
+                    });
+                }
+                return { reply, stale: true, completed: false };
+            }
+            if (silentTurn) {
+                this.logger.debug('completed turn', {
+                    ...turnContext,
+                    durationMs: Date.now() - turnStartedAt,
+                    replyLength: publicReplyText.length,
+                    controlKind: reply?.control?.kind ?? null,
+                    controlMalformed: reply?.controlMalformed ?? false,
+                    delivery: 'silent',
+                });
+                return {
+                    reply,
+                    deliveredMessageId: null,
+                    publicReplyText,
+                    visibleReplyBody,
+                    deliveryState: 'not-delivered',
+                    appliedAttentionSnapshot,
+                    stale: false,
+                    completed: true,
+                };
+            }
+            if (deferDelivery) {
+                this.logger.debug('completed turn', {
+                    ...turnContext,
+                    durationMs: Date.now() - turnStartedAt,
+                    replyLength: publicReplyText.length,
+                    controlKind: reply?.control?.kind ?? null,
+                    controlMalformed: reply?.controlMalformed ?? false,
+                    delivery: 'deferred',
+                });
+                return {
+                    reply,
+                    deliveredMessageId: null,
+                    publicReplyText,
+                    visibleReplyBody,
+                    deliveryState: 'not-delivered',
+                    appliedAttentionSnapshot,
+                    stale: false,
+                    completed: true,
+                };
+            }
+            if (usePublicDraftProgress) {
+                const draft = this.progressDrafts.get(channelId);
+                if (!this.started) {
+                    await draft?.discard().catch(() => { });
+                    this.progressDrafts.delete(channelId);
+                    return { reply, stale: true, completed: false };
+                }
+                const deliveredMessageId = await (draft ?? this.ensureProgressDraft(channelId, activeTurn?.generation, activeTurn?.delivery)).finalize(publicReplyText);
+                this.progressDrafts.delete(channelId);
+                this.logger.debug('completed turn', {
+                    ...turnContext,
+                    durationMs: Date.now() - turnStartedAt,
+                    replyLength: publicReplyText.length,
+                    controlKind: reply?.control?.kind ?? null,
+                    controlMalformed: reply?.controlMalformed ?? false,
+                    delivery: 'draft',
+                });
+                return {
+                    reply,
+                    deliveredMessageId,
+                    publicReplyText,
+                    visibleReplyBody,
+                    deliveryState: deliveredMessageId ? 'draft-finalized' : 'not-delivered',
+                    appliedAttentionSnapshot,
+                    stale: false,
+                    completed: true,
+                };
+            }
+            else if (this.started && !this.controlPlaneClosed && hasVisibleText(publicReplyText)) {
+                const posted = await this.borgee.postMessage({
+                    channelId,
+                    body: visibleReplyBody,
+                    replyToId: activeTurn?.delivery?.replyToId,
+                });
+                this.logger.debug('completed turn', {
+                    ...turnContext,
+                    durationMs: Date.now() - turnStartedAt,
+                    replyLength: publicReplyText.length,
+                    controlKind: reply?.control?.kind ?? null,
+                    controlMalformed: reply?.controlMalformed ?? false,
+                    delivery: 'post',
+                });
+                if (usePrivateCollaborationDraftProgress) {
+                    this.finalizeCollaborationDraft(channelId, activeTurn, posted.messageId, visibleReplyBody);
+                }
+                return {
+                    reply,
+                    deliveredMessageId: posted.messageId,
+                    publicReplyText,
+                    visibleReplyBody,
+                    deliveryState: 'posted',
+                    appliedAttentionSnapshot,
+                    stale: false,
+                    completed: true,
+                };
+            }
+            this.logger.debug('completed turn', {
+                ...turnContext,
+                durationMs: Date.now() - turnStartedAt,
+                replyLength: publicReplyText.length,
+                delivery: usePublicDraftProgress ? 'draft' : 'post',
+            });
+            if (usePrivateCollaborationDraftProgress && activeTurn?.turnExecutionId) {
+                this.clearCollaborationDraft(channelId, {
+                    generation: activeTurn.generation,
+                    turnExecutionId: activeTurn.turnExecutionId,
+                });
+            }
+            return {
+                reply,
+                deliveredMessageId: null,
+                publicReplyText,
+                visibleReplyBody,
+                deliveryState: 'not-delivered',
+                appliedAttentionSnapshot,
+                stale: false,
+                completed: true,
+            };
+        }
+        catch (error) {
+            await this.discardDraft(channelId);
+            if (activeTurn?.turnExecutionId) {
+                this.clearCollaborationDraft(channelId, {
+                    generation: activeTurn.generation,
+                    turnExecutionId: activeTurn.turnExecutionId,
+                });
+            }
+            this.logger.debugError('failed to generate or send reply', {
+                ...turnContext,
+                error,
+            });
+            this.logger.error('failed to generate or send reply', {
+                ...turnContext,
+                error: summarizeError(error),
+            });
+            return {
+                reply,
+                publicReplyText,
+                visibleReplyBody,
+                deliveryState: reply ? 'delivery-failed' : 'not-delivered',
+                stale: activeTurn?.superseded === true,
+                completed: false,
+            };
+        }
+        finally {
+            stopTyping();
+        }
+    }
+    canAcceptTurnOutput(channelId, generation) {
+        if (!this.started || this.controlPlaneClosed) {
+            return false;
+        }
+        if (generation == null) {
+            return true;
+        }
+        const activeTurn = this.collaborationChannels.get(channelId)?.activeTurn;
+        return (activeTurn?.generation === generation &&
+            !activeTurn.superseded &&
+            activeTurn.turnExecutionId != null);
+    }
+    async canAcceptCompletedTurnOutput(channelId, activeTurn) {
+        if (!this.canAcceptTurnOutput(channelId, activeTurn?.generation)) {
+            return false;
+        }
+        if (!activeTurn?.protocol) {
+            return true;
+        }
+        const channelState = this.collaborationChannels.get(channelId);
+        if (!channelState?.protocol) {
+            return false;
+        }
+        if ((await this.canContinueSharedProtocol(channelId, channelState, channelState.protocol)) &&
+            channelState.protocol.anchorMessageId === activeTurn.protocol.anchorMessageId) {
+            return true;
+        }
+        this.supersedeActiveTurn(channelId, activeTurn);
+        return false;
+    }
+    async canContinueSharedProtocol(channelId, channelState, protocolState) {
+        const sharedStatus = await this.readSharedProtocolStatus(channelId, protocolState.anchorMessageId);
+        if (sharedStatus?.active !== false) {
+            return protocolState.active;
+        }
+        protocolState.active = false;
+        protocolState.finished = sharedStatus.finished;
+        channelState.queue = channelState.queue.filter((message) => message.kind !== 'protocol-turn');
+        channelState.recentTurn = undefined;
+        this.clearProtocolFallback(channelState);
+        return false;
+    }
+    enqueueProgressChannelTurn(channelId, task) {
+        const previous = this.progressChannelQueues.get(channelId) ?? Promise.resolve();
+        const next = previous
+            .catch(() => { })
+            .then(task)
+            .finally(() => {
+            if (this.progressChannelQueues.get(channelId) === next) {
+                this.progressChannelQueues.delete(channelId);
+            }
+        });
+        this.progressChannelQueues.set(channelId, next);
+        return next;
+    }
+    ensureProgressDraft(channelId, generation, creationMetadata) {
+        let draft = this.progressDrafts.get(channelId);
+        if (!draft) {
+            draft = new DraftMessageController(this.borgee, channelId, () => !this.controlPlaneClosed && this.canAcceptTurnOutput(channelId, generation), this.logger, creationMetadata);
+            this.progressDrafts.set(channelId, draft);
+        }
+        return draft;
+    }
+    publishCollaborationDraft(channelId, activeTurn, body) {
+        if (!activeTurn?.turnExecutionId || !hasVisibleText(body)) {
+            return;
+        }
+        const generation = activeTurn.generation;
+        const existing = this.collaborationDrafts.get(channelId);
+        if (existing &&
+            (existing.generation !== generation || existing.turnExecutionId !== activeTurn.turnExecutionId)) {
+            this.clearCollaborationDraft(channelId);
+        }
+        const next = this.collaborationDrafts.get(channelId);
+        if (next?.clearTimer) {
+            clearTimeout(next.clearTimer);
+            next.clearTimer = null;
+        }
+        const snapshot = next?.snapshot ?? {
+            draftId: randomUUID(),
+            channelId,
+            turnExecutionId: activeTurn.turnExecutionId,
+            replyToId: activeTurn.delivery?.replyToId,
+            body,
+            status: 'streaming',
+            updatedAt: Date.now(),
+        };
+        snapshot.body = body;
+        snapshot.status = 'streaming';
+        snapshot.updatedAt = Date.now();
+        delete snapshot.finalMessageId;
+        this.collaborationDrafts.set(channelId, {
+            generation,
+            turnExecutionId: activeTurn.turnExecutionId,
+            snapshot,
+            clearTimer: null,
+        });
+    }
+    finalizeCollaborationDraft(channelId, activeTurn, finalMessageId, finalBody) {
+        if (!activeTurn?.turnExecutionId) {
+            this.clearCollaborationDraft(channelId);
+            return;
+        }
+        if (!finalMessageId || !hasVisibleText(finalBody)) {
+            this.clearCollaborationDraft(channelId, {
+                generation: activeTurn.generation,
+                turnExecutionId: activeTurn.turnExecutionId,
+            });
+            return;
+        }
+        const draft = this.collaborationDrafts.get(channelId);
+        if (!draft ||
+            draft.generation !== activeTurn.generation ||
+            draft.turnExecutionId !== activeTurn.turnExecutionId) {
+            return;
+        }
+        if (draft.clearTimer) {
+            clearTimeout(draft.clearTimer);
+        }
+        draft.snapshot.body = finalBody;
+        draft.snapshot.status = 'finalized';
+        draft.snapshot.updatedAt = Date.now();
+        draft.snapshot.finalMessageId = finalMessageId;
+        draft.clearTimer = setTimeout(() => {
+            this.clearCollaborationDraft(channelId, {
+                generation: activeTurn.generation,
+                turnExecutionId: activeTurn.turnExecutionId,
+            });
+        }, COLLABORATION_LATE_SEND_GRACE_MS);
+    }
+    clearCollaborationDraft(channelId, expected) {
+        const draft = this.collaborationDrafts.get(channelId);
+        if (!draft) {
+            return;
+        }
+        if (expected &&
+            (draft.generation !== expected.generation || draft.turnExecutionId !== expected.turnExecutionId)) {
+            return;
+        }
+        if (draft.clearTimer) {
+            clearTimeout(draft.clearTimer);
+        }
+        this.collaborationDrafts.delete(channelId);
+    }
+    readCollaborationDraft(input) {
+        const draft = this.collaborationDrafts.get(input.channelId);
+        if (!draft || draft.turnExecutionId !== input.turnExecutionId) {
+            return null;
+        }
+        return { ...draft.snapshot };
+    }
+    async discardDraft(channelId) {
+        const draft = this.progressDrafts.get(channelId);
+        if (!draft) {
+            return;
+        }
+        this.progressDrafts.delete(channelId);
+        await draft.discard().catch(() => { });
+    }
+    supersedeActiveTurn(channelId, activeTurn) {
+        if (activeTurn.superseded) {
+            return;
+        }
+        this.recordCollaborationOutcome(channelId, {
+            responseState: 'superseded',
+            deliveryState: 'not-delivered',
+            turnExecutionId: activeTurn.turnExecutionId ?? undefined,
+        });
+        if (activeTurn.turnExecutionId) {
+            this.clearCollaborationDraft(channelId, {
+                generation: activeTurn.generation,
+                turnExecutionId: activeTurn.turnExecutionId,
+            });
+        }
+        activeTurn.superseded = true;
+        activeTurn.turnExecutionId = null;
+        void this.discardDraft(channelId);
+    }
+    invalidateChannelTurn(channelId) {
+        const activeTurn = this.collaborationChannels.get(channelId)?.activeTurn;
+        if (activeTurn) {
+            activeTurn.turnExecutionId = null;
+        }
+    }
+    rememberRecentTurn(channelState, activeTurn) {
+        if (!activeTurn.turnExecutionId) {
+            channelState.recentTurn = undefined;
+            return;
+        }
+        channelState.recentTurn = {
+            turnExecutionId: activeTurn.turnExecutionId,
+            superseded: activeTurn.superseded,
+            collaborationMessagesSent: activeTurn.collaborationMessagesSent,
+            targetCooldowns: new Map(activeTurn.targetCooldowns),
+            ...(activeTurn.protocol ? { protocol: activeTurn.protocol } : {}),
+            expiresAt: Date.now() + COLLABORATION_LATE_SEND_GRACE_MS,
+        };
+    }
+    resolveAuthorizedCollaborationTurn(channelState, turnExecutionId) {
+        const activeTurn = channelState?.activeTurn;
+        if (activeTurn &&
+            !activeTurn.superseded &&
+            activeTurn.turnExecutionId != null &&
+            activeTurn.turnExecutionId === turnExecutionId) {
+            return activeTurn;
+        }
+        const recentTurn = channelState?.recentTurn;
+        if (!recentTurn) {
+            return undefined;
+        }
+        if (recentTurn.expiresAt <= Date.now()) {
+            channelState.recentTurn = undefined;
+            return undefined;
+        }
+        if (!recentTurn.superseded && recentTurn.turnExecutionId === turnExecutionId) {
+            return recentTurn;
+        }
+        return undefined;
+    }
+    updateAwaitingUserState(channelId, awaitingUser) {
+        if (awaitingUser) {
+            this.awaitingUserByChannel.set(channelId, awaitingUser);
+            return;
+        }
+        this.awaitingUserByChannel.delete(channelId);
+    }
+    recordBlockedSuppressionOutcome(channelId, channelState) {
+        const blocked = channelState.blocked;
+        if (!blocked) {
+            return;
+        }
+        const existing = this.collaborationOutcomeByChannel.get(channelId);
+        this.recordCollaborationOutcome(channelId, {
+            responseState: 'blocked',
+            deliveryState: existing?.deliveryState ?? 'not-delivered',
+            wakeState: 'suppressed-agent',
+            blockedDetails: {
+                question: blocked.awaitingUser.question,
+                ...(blocked.awaitingUser.reason ? { reason: blocked.awaitingUser.reason } : {}),
+            },
+            turnExecutionId: channelState.activeTurn?.turnExecutionId
+                ?? channelState.recentTurn?.turnExecutionId
+                ?? existing?.turnExecutionId,
+        });
+    }
+    recordCollaborationOutcome(channelId, outcome) {
+        this.collaborationOutcomeByChannel.set(channelId, {
+            source: 'host-observed',
+            responseState: outcome.responseState,
+            deliveryState: outcome.deliveryState,
+            ...(outcome.wakeState ? { wakeState: outcome.wakeState } : {}),
+            ...(outcome.blockedDetails ? { blockedDetails: outcome.blockedDetails } : {}),
+            observedAt: outcome.observedAt ?? Date.now(),
+            ...(outcome.turnExecutionId ? { turnExecutionId: outcome.turnExecutionId } : {}),
+        });
+        this.syncMissedCollaborationDiagnosticFromOutcome(channelId);
+    }
+    syncMissedCollaborationDiagnosticFromOutcome(channelId) {
+        if (!this.collaborationCapabilitiesDiagnosticsEnabled) {
+            this.missedCollaborationDiagnosticByChannel.delete(channelId);
+            return;
+        }
+        const outcome = this.collaborationOutcomeByChannel.get(channelId);
+        if (!outcome) {
+            this.missedCollaborationDiagnosticByChannel.delete(channelId);
+            return;
+        }
+        if (outcome.responseState === 'blocked'
+            && outcome.wakeState === 'waiting'
+            && outcome.blockedDetails) {
+            this.updateMissedCollaborationDiagnostic(channelId, {
+                stage: 'response',
+                reason: 'blocked-awaiting-user',
+            });
+            return;
+        }
+        if (outcome.responseState === 'superseded') {
+            this.updateMissedCollaborationDiagnostic(channelId, undefined);
+            return;
+        }
+        if (!this.collaborationOutcomeModelEnabled) {
+            this.updateMissedCollaborationDiagnostic(channelId, undefined);
+            return;
+        }
+        if (outcome.deliveryState === 'delivery-failed') {
+            this.updateMissedCollaborationDiagnostic(channelId, {
+                stage: 'delivery',
+                reason: 'delivery-failed',
+            });
+            return;
+        }
+        if (outcome.deliveryState === 'not-delivered' && outcome.responseState !== 'failed') {
+            this.updateMissedCollaborationDiagnostic(channelId, {
+                stage: 'delivery',
+                reason: 'not-delivered',
+            });
+            return;
+        }
+        this.updateMissedCollaborationDiagnostic(channelId, undefined);
+    }
+    resolveVisibleTurnBody(activeTurn, reply, publicReplyText) {
+        if (!activeTurn?.protocol || !this.shouldRelayProtocolReply(activeTurn, reply)) {
+            return publicReplyText;
+        }
+        return appendVisibleBodyMention(publicReplyText, activeTurn.protocol.targetPeerId);
+    }
+    shouldRelayProtocolReply(activeTurn, reply) {
+        const protocol = activeTurn.protocol;
+        return (protocol != null &&
+            reply.control?.kind === 'continue-to-peer' &&
+            protocol.turnIndex < protocol.maxTurnCount);
+    }
+    async normalizeMessage(msg) {
+        this.logger.debug('received channel event', {
+            eventType: msg.type,
+            messageType: msg.message_type,
+            provider: this.config.agent.provider,
+            agentName: this.config.agent.agentName,
+            channelId: msg.channel_id,
+            messageId: msg.message_id,
+        });
+        if (!isReplyTriggeringEventType(msg.type)) {
+            this.logger.debug('ignored non-triggering channel event', {
+                eventType: msg.type,
+                messageType: msg.message_type,
+                channelId: msg.channel_id,
+                messageId: msg.message_id,
+            });
+            return null;
+        }
+        const selfAgentId = await this.ensureSelfAgentId();
+        const authorId = String(msg.user_id ?? msg.sender_id ?? 'unknown');
+        if (authorId === selfAgentId && msg.message_type !== 'task_assignment') {
+            this.logger.debug('ignored self-authored message', {
+                channelId: msg.channel_id,
+                messageId: msg.message_id,
+            });
+            return null;
+        }
+        const content = String(msg.content ?? msg.body ?? '').trim();
+        if (!content) {
+            this.logger.debug('ignored empty message', {
+                channelId: msg.channel_id,
+                messageId: msg.message_id,
+            });
+            return null;
+        }
+        return {
+            authorId,
+            content,
+        };
+    }
+    async markAssignedTaskInProgress(threadId, content) {
+        try {
+            const selfAgentId = await this.ensureSelfAgentId();
+            const task = await waitForTaskForThread(this.borgee, threadId, {
+                preferredTaskId: extractTaskIdFromTaskAssignmentContent(content),
+                attempts: 10,
+                delayMs: 250,
+            });
+            if (!task || task.status !== 'open' || task.assigneeId !== selfAgentId) {
+                return;
+            }
+            await this.borgee.updateTask({
+                taskId: task.id,
+                status: 'in_progress',
+            });
+        }
+        catch (error) {
+            this.logger.debugError('best-effort task auto-start failed', {
+                channelId: threadId,
+                error,
+            });
+        }
+    }
+    async ensureSelfAgentId() {
+        if (this.selfAgentId) {
+            return this.selfAgentId;
+        }
+        if (!this.selfAgentIdPromise) {
+            this.selfAgentIdPromise = this.borgee
+                .getMe()
+                .then((me) => {
+                this.selfAgentId = me.id;
+                this.selfAgentProfile = me;
+                this.participantKindsByUserId.set(me.id, 'agent');
+                this.participantDirectoryByUserId.set(me.id, {
+                    id: me.id,
+                    display_name: me.display_name,
+                    kind: 'agent',
+                });
+                return me.id;
+            })
+                .catch((error) => {
+                this.selfAgentIdPromise = null;
+                throw error;
+            });
+        }
+        return this.selfAgentIdPromise;
+    }
+    async classifyAuthor(authorId, forceRefreshOnMiss) {
+        const cached = this.participantKindsByUserId.get(authorId);
+        if (cached) {
+            return cached === 'agent' ? 'agent' : 'human';
+        }
+        if (!this.participantDirectorySupported) {
+            return this.inferAuthorKind(authorId);
+        }
+        const now = Date.now();
+        const nextRefreshAt = this.participantRefreshBackoffByUserId.get(authorId) ?? 0;
+        if (forceRefreshOnMiss || now >= nextRefreshAt) {
+            await this.refreshParticipantDirectory();
+            const refreshed = this.participantKindsByUserId.get(authorId);
+            if (refreshed) {
+                this.participantRefreshBackoffByUserId.delete(authorId);
+                return refreshed === 'agent' ? 'agent' : 'human';
+            }
+            this.participantRefreshBackoffByUserId.set(authorId, now + BLOCKED_AUTHOR_REFRESH_BACKOFF_MS);
+        }
+        return 'unknown';
+    }
+    async refreshParticipantDirectory() {
+        if (!this.participantDirectorySupported) {
+            return;
+        }
+        if (!this.participantRefreshPromise) {
+            this.participantRefreshPromise = this.borgee
+                .listUsers()
+                .then((users) => {
+                const nextKinds = new Map();
+                const nextDirectory = new Map();
+                for (const user of users) {
+                    nextKinds.set(user.id, user.kind);
+                    nextDirectory.set(user.id, user);
+                }
+                if (this.selfAgentId) {
+                    nextKinds.set(this.selfAgentId, 'agent');
+                    nextDirectory.set(this.selfAgentId, {
+                        id: this.selfAgentId,
+                        display_name: this.selfAgentProfile?.display_name,
+                        kind: 'agent',
+                    });
+                }
+                this.participantKindsByUserId.clear();
+                this.participantDirectoryByUserId.clear();
+                for (const [userId, kind] of nextKinds) {
+                    this.participantKindsByUserId.set(userId, kind);
+                }
+                for (const [userId, user] of nextDirectory) {
+                    this.participantDirectoryByUserId.set(userId, user);
+                }
+            })
+                .catch((error) => {
+                if (this.isUnsupportedSemanticOperation(error, 'list_users')) {
+                    this.participantDirectorySupported = false;
+                    return;
+                }
+                this.logger.error('failed to refresh participant directory', {
+                    error: summarizeError(error),
+                });
+            })
+                .finally(() => {
+                this.participantRefreshPromise = null;
+            });
+        }
+        await this.participantRefreshPromise;
+    }
+    async classifyBlockedWakeAuthor(authorId, blockedState) {
+        void blockedState;
+        return this.classifyAuthor(authorId, true);
+    }
+    async classifyQueuedBlockedWakeCandidate(message, blockedState) {
+        void blockedState;
+        return this.classifyAuthor(message.authorId, true);
+    }
+    inferAuthorKind(authorId) {
+        if (this.selfAgentId === authorId) {
+            return 'agent';
+        }
+        if (authorId.includes('@')) {
+            return 'human';
+        }
+        if (authorId.startsWith('user-') || authorId.startsWith('human-')) {
+            return 'human';
+        }
+        if (authorId.startsWith('agent-')) {
+            return 'agent';
+        }
+        return 'unknown';
+    }
+    async buildCollaborationGrounding(authorId, incomingAuthorKind, activeTurn, kickoff) {
+        if (!activeTurn?.protocol && !kickoff) {
+            return undefined;
+        }
+        const selfAgentId = await this.ensureSelfAgentId();
+        const peerId = activeTurn?.protocol?.targetPeerId ??
+            kickoff?.participantIds.find((participantId) => participantId !== selfAgentId);
+        const participantIds = kickoff?.participantIds ?? (peerId ? [selfAgentId, peerId] : [selfAgentId]);
+        await this.hydratePromptIdentityCache([selfAgentId, authorId, ...participantIds]);
+        return {
+            self: this.resolvePromptIdentity(selfAgentId, 'agent'),
+            incomingAuthor: this.resolvePromptIdentity(authorId, incomingAuthorKind ?? 'unknown'),
+            ...(peerId ? { peer: this.resolvePromptIdentity(peerId, 'agent') } : {}),
+            participants: participantIds.map((participantId) => this.resolvePromptIdentity(participantId, 'agent')),
+            ...(kickoff ? { hostRecognizedKickoffCandidate: true } : {}),
+        };
+    }
+    async hydratePromptIdentityCache(userIds) {
+        if (!this.participantDirectorySupported) {
+            return;
+        }
+        const unresolved = [...new Set(userIds)].filter((userId) => !this.participantDirectoryByUserId.has(userId));
+        if (unresolved.length === 0) {
+            return;
+        }
+        await this.refreshParticipantDirectory();
+    }
+    resolvePromptIdentity(userId, fallbackKind) {
+        const directoryUser = this.participantDirectoryByUserId.get(userId);
+        if (this.selfAgentId === userId) {
+            return {
+                id: userId,
+                displayName: this.selfAgentProfile?.display_name ??
+                    directoryUser?.display_name ??
+                    this.config.agent.agentName,
+                kind: 'agent',
+            };
+        }
+        return {
+            id: userId,
+            displayName: directoryUser?.display_name,
+            kind: (directoryUser?.kind === 'user' ? 'human' : directoryUser?.kind) ?? fallbackKind,
+        };
+    }
+    isUnsupportedSemanticOperation(error, op) {
+        if (!error || typeof error !== 'object') {
+            return false;
+        }
+        const code = 'code' in error ? error.code : undefined;
+        const message = 'message' in error ? error.message : undefined;
+        return (code === 'bpp.semantic_op_unknown' && typeof message === 'string' && message.includes(op));
+    }
+    authorizeCollaborationSend(input) {
+        if (!this.collaborationEnabled) {
+            return { ok: false, statusCode: 403, error: 'collaboration_not_enabled' };
+        }
+        const channelState = this.collaborationChannels.get(input.channelId);
+        const authorizedTurn = this.resolveAuthorizedCollaborationTurn(channelState, input.turnExecutionId);
+        if (!authorizedTurn) {
+            return { ok: false, statusCode: 409, error: 'stale_turn_execution_id' };
+        }
+        if (authorizedTurn.protocol) {
+            return { ok: false, statusCode: 403, error: 'protocol_managed_turn' };
+        }
+        if (authorizedTurn.collaborationMessagesSent >= COLLABORATION_SENDS_PER_TURN) {
+            return { ok: false, statusCode: 429, error: 'collaboration_quota_exceeded' };
+        }
+        const targetKey = [
+            input.replyToId ? `reply:${input.replyToId}` : '',
+            input.mentions.length > 0 ? `mentions:${[...new Set(input.mentions)].sort().join(',')}` : '',
+        ]
+            .filter((value) => value.length > 0)
+            .join('|');
+        const existingCooldownUntil = authorizedTurn.targetCooldowns.get(targetKey) ?? 0;
+        if (existingCooldownUntil > Date.now()) {
+            return { ok: false, statusCode: 429, error: 'collaboration_target_cooldown' };
+        }
+        const cooldownUntil = Date.now() + LOCALHOST_GATEWAY_COLLABORATION_TARGET_COOLDOWN_MS;
+        authorizedTurn.collaborationMessagesSent += 1;
+        authorizedTurn.targetCooldowns.set(targetKey, cooldownUntil);
+        let settled = false;
+        return {
+            ok: true,
+            statusCode: 200,
+            commit: () => {
+                settled = true;
+            },
+            rollback: () => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                authorizedTurn.collaborationMessagesSent = Math.max(0, authorizedTurn.collaborationMessagesSent - 1);
+                if (authorizedTurn.targetCooldowns.get(targetKey) === cooldownUntil) {
+                    authorizedTurn.targetCooldowns.delete(targetKey);
+                }
+            },
+        };
     }
 }