@borgee/agents-host 0.2.26 → 0.2.28

package/dist/compatibility-gates.d.ts

@@ -6,6 +6,10 @@ export declare const CONTEXT_INJECTION_COMPATIBILITY_GATE = "context-injection";
 export declare const SKILL_RUNTIME_COMPATIBILITY_GATE = "skill-runtime";
 export declare const LOCALHOST_GATEWAY_COMPATIBILITY_GATE = "localhost-gateway";
 export declare const COLLABORATION_SKILL_FIRST_COMPATIBILITY_GATE = "collaboration-skill-first";
+export declare const COLLABORATION_OUTCOME_MODEL_COMPATIBILITY_GATE = "collaboration-outcome-model";
+export declare const ATTENTION_FOLLOW_SEMANTICS_COMPATIBILITY_GATE = "attention-follow-semantics";
+export declare const TASK_THREAD_COLLABORATION_CONTRACT_COMPATIBILITY_GATE = "task-thread-collaboration-contract";
+export declare const COLLABORATION_CAPABILITIES_DIAGNOSTICS_COMPATIBILITY_GATE = "collaboration-capabilities-diagnostics";
 export declare const TOKEN_BINDING_COMPATIBILITY_GATE = "token-binding";
 export declare const POLICY_AUDIT_ENFORCEMENT_COMPATIBILITY_GATE = "policy-audit-enforcement";
 export declare const MANAGED_RUNTIME_CONVERGENCE_COMPATIBILITY_GATE = "managed-runtime-convergence";

package/dist/compatibility-gates.js

@@ -7,6 +7,10 @@ export const CONTEXT_INJECTION_COMPATIBILITY_GATE = 'context-injection';
 export const SKILL_RUNTIME_COMPATIBILITY_GATE = 'skill-runtime';
 export const LOCALHOST_GATEWAY_COMPATIBILITY_GATE = 'localhost-gateway';
 export const COLLABORATION_SKILL_FIRST_COMPATIBILITY_GATE = 'collaboration-skill-first';
+export const COLLABORATION_OUTCOME_MODEL_COMPATIBILITY_GATE = 'collaboration-outcome-model';
+export const ATTENTION_FOLLOW_SEMANTICS_COMPATIBILITY_GATE = 'attention-follow-semantics';
+export const TASK_THREAD_COLLABORATION_CONTRACT_COMPATIBILITY_GATE = 'task-thread-collaboration-contract';
+export const COLLABORATION_CAPABILITIES_DIAGNOSTICS_COMPATIBILITY_GATE = 'collaboration-capabilities-diagnostics';
 export const TOKEN_BINDING_COMPATIBILITY_GATE = 'token-binding';
 export const POLICY_AUDIT_ENFORCEMENT_COMPATIBILITY_GATE = 'policy-audit-enforcement';
 export const MANAGED_RUNTIME_CONVERGENCE_COMPATIBILITY_GATE = 'managed-runtime-convergence';

package/dist/context/attention.d.ts

@@ -0,0 +1,12 @@
+import type { AttentionClaimActivation, AttentionClaimContext, AttentionClaimState, AttentionDeliveryMode, AttentionSnapshot, AttentionWakeMode } from '../types.js';
+export declare function deriveAttentionWakeMode(snapshot: Pick<AttentionSnapshot, 'deliveryMode' | 'claimState' | 'claimActivation'>): AttentionWakeMode;
+export declare function buildNormalizedAttentionSnapshot(params?: {
+    deliveryMode?: AttentionDeliveryMode;
+    claimState?: AttentionClaimState;
+    claimActivation?: AttentionClaimActivation;
+    observedAt?: number;
+    turnExecutionId?: string;
+    claimContext?: AttentionClaimContext;
+}): AttentionSnapshot;
+export declare function parsePersistedAttentionSnapshot(raw: unknown): AttentionSnapshot;
+export declare function buildAttentionSummaryLines(snapshot: AttentionSnapshot | undefined): string[];

package/dist/context/attention.js

@@ -0,0 +1,137 @@
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isDeliveryMode(value) {
+    return value === 'default' || value === 'follow' || value === 'muted';
+}
+function isClaimState(value) {
+    return value === 'unclaimed' || value === 'claimed';
+}
+function isClaimActivation(value) {
+    return value === 'inactive' || value === 'active' || value === 'dormant';
+}
+function isUsableTaskId(value) {
+    return value.length > 0 && !/[\u0000-\u001f\u007f\s]/u.test(value);
+}
+function normalizeClaimContext(value) {
+    if (!isRecord(value) || typeof value.scope !== 'string' || typeof value.taskId !== 'string') {
+        return undefined;
+    }
+    const taskId = value.taskId.trim();
+    if (value.scope === 'task-thread') {
+        return isUsableTaskId(taskId) ? { scope: 'task-thread', taskId } : undefined;
+    }
+    if (value.scope === 'channel') {
+        return isUsableTaskId(taskId) ? { scope: 'channel', taskId } : undefined;
+    }
+    return undefined;
+}
+export function deriveAttentionWakeMode(snapshot) {
+    if (snapshot.deliveryMode === 'muted') {
+        return 'mute-non-mention';
+    }
+    if (snapshot.deliveryMode === 'follow') {
+        return 'follow-visible-human';
+    }
+    if (snapshot.claimState === 'claimed' && snapshot.claimActivation === 'active') {
+        return 'follow-visible-human';
+    }
+    return 'current-policy';
+}
+export function buildNormalizedAttentionSnapshot(params) {
+    let deliveryMode = params?.deliveryMode ?? 'default';
+    let claimState = params?.claimState ?? 'unclaimed';
+    let claimActivation = params?.claimActivation ?? 'inactive';
+    let claimContext = params?.claimContext;
+    if (claimState === 'unclaimed') {
+        claimActivation = 'inactive';
+        claimContext = undefined;
+    }
+    else if (claimActivation === 'inactive') {
+        claimState = 'unclaimed';
+        claimContext = undefined;
+    }
+    if (claimActivation === 'dormant') {
+        deliveryMode = 'default';
+    }
+    if (claimContext?.scope === 'task-thread' && !isUsableTaskId(claimContext.taskId)) {
+        claimState = 'unclaimed';
+        claimActivation = 'inactive';
+        claimContext = undefined;
+        deliveryMode = 'default';
+    }
+    const snapshot = {
+        source: 'host-observed',
+        deliveryMode,
+        claimState,
+        claimActivation,
+        wakeMode: deriveAttentionWakeMode({
+            deliveryMode,
+            claimState,
+            claimActivation,
+        }),
+        observedAt: params?.observedAt ?? Date.now(),
+        ...(params?.turnExecutionId ? { turnExecutionId: params.turnExecutionId } : {}),
+        ...(claimContext ? { claimContext } : {}),
+    };
+    return snapshot;
+}
+export function parsePersistedAttentionSnapshot(raw) {
+    if (!isRecord(raw)) {
+        return buildNormalizedAttentionSnapshot();
+    }
+    const deliveryMode = isDeliveryMode(raw.deliveryMode) ? raw.deliveryMode : 'default';
+    const claimState = isClaimState(raw.claimState) ? raw.claimState : 'unclaimed';
+    const claimActivation = isClaimActivation(raw.claimActivation) ? raw.claimActivation : 'inactive';
+    const observedAt = typeof raw.observedAt === 'number' && Number.isFinite(raw.observedAt)
+        ? raw.observedAt
+        : Date.now();
+    const turnExecutionId = typeof raw.turnExecutionId === 'string' && raw.turnExecutionId.trim().length > 0
+        ? raw.turnExecutionId
+        : undefined;
+    const claimContext = normalizeClaimContext(raw.claimContext);
+    const normalized = buildNormalizedAttentionSnapshot({
+        deliveryMode,
+        claimState,
+        claimActivation,
+        observedAt,
+        turnExecutionId,
+        claimContext,
+    });
+    if (normalized.claimContext?.scope === 'task-thread') {
+        return buildNormalizedAttentionSnapshot({
+            deliveryMode: 'default',
+            claimState: normalized.claimState,
+            claimActivation: 'dormant',
+            observedAt: normalized.observedAt,
+            turnExecutionId: normalized.turnExecutionId,
+            claimContext: normalized.claimContext,
+        });
+    }
+    return normalized;
+}
+function formatObservedAt(observedAt) {
+    return new Date(observedAt).toISOString();
+}
+export function buildAttentionSummaryLines(snapshot) {
+    if (!snapshot) {
+        return [];
+    }
+    return [
+        'Host-observed attention snapshot for this channel (projection only; not server-authoritative truth).',
+        `Delivery mode: ${snapshot.deliveryMode}`,
+        `Claim state: ${snapshot.claimState}`,
+        `Claim activation: ${snapshot.claimActivation}`,
+        `Wake mode: ${snapshot.wakeMode}`,
+        ...(snapshot.claimContext
+            ? [
+                `Claim scope: ${snapshot.claimContext.scope}`,
+                `Claim task id: ${snapshot.claimContext.taskId}`,
+            ]
+            : []),
+        `Observed at: ${formatObservedAt(snapshot.observedAt)}`,
+        ...(snapshot.turnExecutionId
+            ? [`Observed turn execution id: ${snapshot.turnExecutionId}`]
+            : []),
+    ];
+}

package/dist/context/collaboration-capabilities-diagnostics.d.ts

@@ -0,0 +1,3 @@
+import type { CollaborationCapabilityDeclaration, MissedCollaborationDiagnostic } from '../types.js';
+export declare function buildCollaborationCapabilityDeclarationSummaryLines(declaration: CollaborationCapabilityDeclaration | undefined): string[];
+export declare function buildMissedCollaborationDiagnosticSummaryLines(diagnostic: MissedCollaborationDiagnostic | undefined): string[];

package/dist/context/collaboration-capabilities-diagnostics.js

@@ -0,0 +1,18 @@
+export function buildCollaborationCapabilityDeclarationSummaryLines(declaration) {
+    if (!declaration) {
+        return [];
+    }
+    return [
+        'Shared hosted collaboration capability declaration (projection only; hosted-path vocabulary only, not authorization, action availability, thread-binding authority, or standalone-runtime parity).',
+        `Capability declaration: ${JSON.stringify(declaration)}`,
+    ];
+}
+export function buildMissedCollaborationDiagnosticSummaryLines(diagnostic) {
+    if (!diagnostic) {
+        return [];
+    }
+    return [
+        'Latest hosted missed-collaboration diagnostic (projection only; delivery, wake, or response explanation only).',
+        `Missed-collaboration diagnostic: ${JSON.stringify(diagnostic)}`,
+    ];
+}

package/dist/context/collaboration-outcome.d.ts

@@ -0,0 +1,2 @@
+import type { CollaborationOutcomeSnapshot } from '../types.js';
+export declare function buildCollaborationOutcomeSummaryLines(snapshot: CollaborationOutcomeSnapshot | undefined): string[];

package/dist/context/collaboration-outcome.js

@@ -0,0 +1,26 @@
+function formatObservedAt(observedAt) {
+    return new Date(observedAt).toISOString();
+}
+export function buildCollaborationOutcomeSummaryLines(snapshot) {
+    if (!snapshot) {
+        return [];
+    }
+    return [
+        'Host-observed collaboration outcome snapshot for this channel (projection only; not provider-authoritative truth).',
+        `Response state: ${snapshot.responseState}`,
+        `Delivery state: ${snapshot.deliveryState}`,
+        ...(snapshot.wakeState ? [`Wake state: ${snapshot.wakeState}`] : []),
+        ...(snapshot.blockedDetails
+            ? [
+                `Blocked question: ${snapshot.blockedDetails.question}`,
+                ...(snapshot.blockedDetails.reason
+                    ? [`Blocked reason: ${snapshot.blockedDetails.reason}`]
+                    : []),
+            ]
+            : []),
+        `Observed at: ${formatObservedAt(snapshot.observedAt)}`,
+        ...(snapshot.turnExecutionId
+            ? [`Observed turn execution id: ${snapshot.turnExecutionId}`]
+            : []),
+    ];
+}

package/dist/context/injection.d.ts

@@ -1,4 +1,4 @@
-import type { LocalhostGatewayBootstrapMetadata, ProviderCollaborationContext, SkillRuntimeBootstrapMetadata, TaskAssignmentThreadContext, TaskWorkspaceContext } from '../types.js';
+import type { AttentionSnapshot, CollaborationCapabilityDeclaration, CollaborationOutcomeSnapshot, LocalhostGatewayBootstrapMetadata, MissedCollaborationDiagnostic, ProviderCollaborationContext, SkillRuntimeBootstrapMetadata, TaskThreadCollaborationContract, TaskAssignmentThreadContext, TaskWorkspaceContext } from '../types.js';
 export interface SkillRuntimeBootstrapPayload {
     skillDirectoryPath: string;
     nodeCliPath: string;
@@ -7,6 +7,11 @@ export interface SkillRuntimeBootstrapPayload {
 export interface ChannelContextPayload {
     schemaVersion: 1;
     channelId: string;
+    collaborationOutcome?: CollaborationOutcomeSnapshot;
+    attentionSnapshot?: AttentionSnapshot;
+    taskThreadCollaborationContract?: TaskThreadCollaborationContract;
+    collaborationCapabilities?: CollaborationCapabilityDeclaration;
+    missedCollaborationDiagnostic?: MissedCollaborationDiagnostic;
     skillRuntime?: SkillRuntimeBootstrapPayload;
     localhostGateway?: LocalhostGatewayBootstrapMetadata;
     taskAssignmentContext?: TaskAssignmentThreadContext;
@@ -29,11 +34,21 @@ export interface ChannelContextStore {
     prepare(input: {
         channelId: string;
         collaboration?: ProviderCollaborationContext;
+        collaborationOutcome?: CollaborationOutcomeSnapshot;
+        attentionSnapshot?: AttentionSnapshot;
+        taskThreadCollaborationContract?: TaskThreadCollaborationContract;
+        collaborationCapabilities?: CollaborationCapabilityDeclaration;
+        missedCollaborationDiagnostic?: MissedCollaborationDiagnostic;
         incomingMessageType?: string;
         incomingContent?: string;
     }): Promise<PreparedChannelContext>;
     prepare(channelId: string, options?: {
         collaboration?: ProviderCollaborationContext;
+        collaborationOutcome?: CollaborationOutcomeSnapshot;
+        attentionSnapshot?: AttentionSnapshot;
+        taskThreadCollaborationContract?: TaskThreadCollaborationContract;
+        collaborationCapabilities?: CollaborationCapabilityDeclaration;
+        missedCollaborationDiagnostic?: MissedCollaborationDiagnostic;
         incomingMessageType?: string;
         incomingContent?: string;
     }): Promise<PreparedChannelContext>;
@@ -97,10 +112,20 @@ export declare class FileChannelContextStore implements ChannelContextStore {
     prepare(inputOrChannelId: {
         channelId: string;
         collaboration?: ProviderCollaborationContext;
+        collaborationOutcome?: CollaborationOutcomeSnapshot;
+        attentionSnapshot?: AttentionSnapshot;
+        taskThreadCollaborationContract?: TaskThreadCollaborationContract;
+        collaborationCapabilities?: CollaborationCapabilityDeclaration;
+        missedCollaborationDiagnostic?: MissedCollaborationDiagnostic;
         incomingMessageType?: string;
         incomingContent?: string;
     } | string, options?: {
         collaboration?: ProviderCollaborationContext;
+        collaborationOutcome?: CollaborationOutcomeSnapshot;
+        attentionSnapshot?: AttentionSnapshot;
+        taskThreadCollaborationContract?: TaskThreadCollaborationContract;
+        collaborationCapabilities?: CollaborationCapabilityDeclaration;
+        missedCollaborationDiagnostic?: MissedCollaborationDiagnostic;
         incomingMessageType?: string;
         incomingContent?: string;
     }): Promise<PreparedChannelContext>;

package/dist/context/injection.js

@@ -57,10 +57,15 @@ function buildLocalhostGatewayAuthPayload(channelId, localhostGateway) {
         },
     };
 }
-function buildChannelContextPayload(channelId, skillRuntime, localhostGateway, options) {
+function buildChannelContextPayload(channelId, collaborationOutcome, attentionSnapshot, taskThreadCollaborationContract, collaborationCapabilities, missedCollaborationDiagnostic, skillRuntime, localhostGateway, options) {
     return {
         schemaVersion: 1,
         channelId,
+        ...(collaborationOutcome ? { collaborationOutcome } : {}),
+        ...(attentionSnapshot ? { attentionSnapshot } : {}),
+        ...(taskThreadCollaborationContract ? { taskThreadCollaborationContract } : {}),
+        ...(collaborationCapabilities ? { collaborationCapabilities } : {}),
+        ...(missedCollaborationDiagnostic ? { missedCollaborationDiagnostic } : {}),
         ...(skillRuntime ? { skillRuntime: toSkillRuntimePayload(skillRuntime) } : {}),
         ...(localhostGateway ? { localhostGateway } : {}),
         ...(options?.taskAssignmentContext ? { taskAssignmentContext: options.taskAssignmentContext } : {}),
@@ -281,7 +286,7 @@ export class FileChannelContextStore {
                 rootPath: resolveTaskWorkspaceDirectory(this.startupWorkspaceRootDir, input.channelId, taskAssignmentContext.currentTaskId),
             }
             : undefined;
-        const payload = buildChannelContextPayload(input.channelId, skillRuntime, localhostGateway, taskAssignmentContext || taskWorkspace
+        const payload = buildChannelContextPayload(input.channelId, input.collaborationOutcome, input.attentionSnapshot, input.taskThreadCollaborationContract, input.collaborationCapabilities, input.missedCollaborationDiagnostic, skillRuntime, localhostGateway, taskAssignmentContext || taskWorkspace
             ? {
                 ...(taskAssignmentContext ? { taskAssignmentContext } : {}),
                 ...(taskWorkspace ? { taskWorkspace } : {}),

package/dist/context/prompt.js

@@ -1,4 +1,8 @@
 import { AWAITING_USER_CONTROL_PREFIX } from '../providers/awaiting-user.js';
+import { buildAttentionSummaryLines } from './attention.js';
+import { buildCollaborationCapabilityDeclarationSummaryLines, buildMissedCollaborationDiagnosticSummaryLines, } from './collaboration-capabilities-diagnostics.js';
+import { buildCollaborationOutcomeSummaryLines } from './collaboration-outcome.js';
+import { buildTaskThreadCollaborationSummaryLines } from './task-thread-collaboration.js';
 function providerLabel(provider) {
     if (provider === 'copilot') {
         return 'GitHub Copilot';
@@ -89,6 +93,10 @@ function buildInboundMetadataLines(params) {
     return [
         `Incoming transport event kind: ${params.incomingEventKind?.trim() || 'message'}`,
         `Incoming semantic message type: ${params.incomingMessageType?.trim() || 'default'}`,
+        ...(() => {
+            const lines = buildTaskThreadCollaborationSummaryLines(params.promptContext?.taskThreadCollaborationContract);
+            return lines.length > 0 ? ['', ...lines] : [];
+        })(),
         ...buildTaskAssignmentPromptLines(params),
     ];
 }
@@ -101,10 +109,37 @@ function describeIdentity(identity) {
     return `${label}, kind=${identity.kind}`;
 }
 function buildTurnControlPromptLines(context) {
+    const taskThreadAttentionAvailable = context?.taskAssignmentContext?.active === true
+        && typeof context.taskAssignmentContext.currentTaskId === 'string'
+        && context.taskAssignmentContext.currentTaskId.trim().length > 0;
+    const attentionLines = context?.attentionSnapshot
+        ? [
+            'Attention controls are projection-only host hints. They do not bypass server-side mention policy or widen message delivery.',
+            `To follow ordinary delivered human messages in this channel, add "attentionUpdate":"follow-channel".`,
+            `To stop follow-based human wake for this channel, add "attentionUpdate":"unfollow-channel".`,
+            `To mute ordinary delivered human wake while keeping explicit mentions and task assignments untouched, add "attentionUpdate":"mute-channel".`,
+            `To set a durable channel-level attention hint, add "attentionUpdate":"claim-channel".`,
+            ...(taskThreadAttentionAvailable
+                ? [
+                    `To set a durable task-thread attention hint, add "attentionUpdate":"claim-task-thread" only when this turn has active injected task-thread context with a usable currentTaskId.`,
+                    `To clear a local claim without changing deliveryMode, add "attentionUpdate":"unclaim-channel" or "attentionUpdate":"unclaim-task-thread".`,
+                ]
+                : [
+                    `To clear a local channel claim without changing deliveryMode, add "attentionUpdate":"unclaim-channel".`,
+                ]),
+        ]
+        : [];
+    const attentionOnlyLine = context?.attentionSnapshot
+        ? [
+            `For an attention-only reply, keep a non-empty visible body and append: ${AWAITING_USER_CONTROL_PREFIX}{"kind":"attention-only","attentionUpdate":"follow-channel"}`,
+        ]
+        : [];
     if (!context) {
         return [
             `Only when you need host-local turn control, append exactly one final non-empty line starting with ${AWAITING_USER_CONTROL_PREFIX}.`,
             `For ordinary blocked-on-human turns, use: ${AWAITING_USER_CONTROL_PREFIX}{"kind":"awaiting-user","question":"<short question>","reason":"<short reason>"}`,
+            ...attentionLines,
+            ...attentionOnlyLine,
             'Do not emit multiple control lines, and do not use a control footer for ordinary answers.',
         ];
     }
@@ -123,6 +158,10 @@ function buildTurnControlPromptLines(context) {
             `When handing off to the named peer, use: ${AWAITING_USER_CONTROL_PREFIX}{"kind":"continue-to-peer"}`,
             `When finishing locally, use: ${AWAITING_USER_CONTROL_PREFIX}{"kind":"conclude-locally"}`,
             `If you are blocked on the human instead, use: ${AWAITING_USER_CONTROL_PREFIX}{"kind":"awaiting-user","question":"<short question>","reason":"<short reason>"}`,
+            ...(context.attentionSnapshot
+                ? ['You may add one attentionUpdate field to continue-to-peer, conclude-locally, or awaiting-user when you also need an attention change for this channel.']
+                : []),
+            ...attentionLines,
             'Do not emit multiple control lines, and do not use start-protocol while host-managed collaboration is already active.',
         ];
     }
@@ -151,6 +190,7 @@ function buildTurnControlPromptLines(context) {
             ...(participantSummary ? [`Visible kickoff participants: ${participantSummary}.`] : []),
             'This evaluation is read-only and silent: do not use auxiliary collaboration send commands, and do not draft a user-visible reply body for this turn.',
             `If the anchor message is genuinely requesting host-managed collaboration between the named agents, use: ${AWAITING_USER_CONTROL_PREFIX}{"kind":"start-protocol","rounds":<positive integer>}`,
+            'Do not combine start-protocol with any attentionUpdate field.',
             'If collaboration should not start, omit the control footer entirely.',
             'Do not emit multiple control lines.',
         ];
@@ -158,6 +198,11 @@ function buildTurnControlPromptLines(context) {
     return [
         `Only when you need host-local turn control, append exactly one final non-empty line starting with ${AWAITING_USER_CONTROL_PREFIX}.`,
         `For ordinary blocked-on-human turns, use: ${AWAITING_USER_CONTROL_PREFIX}{"kind":"awaiting-user","question":"<short question>","reason":"<short reason>"}`,
+        ...(context?.attentionSnapshot
+            ? ['You may add one attentionUpdate field to awaiting-user when you also need an attention change for this channel.']
+            : []),
+        ...attentionLines,
+        ...attentionOnlyLine,
         'Do not emit multiple control lines, and do not use a control footer for ordinary answers.',
     ];
 }
@@ -184,6 +229,22 @@ export function buildPrompt(params) {
             incomingMessageType: params.incomingMessageType,
             promptContext: params.promptContext,
         }),
+        ...(() => {
+            const lines = buildCollaborationOutcomeSummaryLines(params.promptContext?.collaborationOutcome);
+            return lines.length > 0 ? ['', ...lines] : [];
+        })(),
+        ...(() => {
+            const lines = buildAttentionSummaryLines(params.promptContext?.attentionSnapshot);
+            return lines.length > 0 ? ['', ...lines] : [];
+        })(),
+        ...(() => {
+            const lines = buildCollaborationCapabilityDeclarationSummaryLines(params.promptContext?.collaborationCapabilities);
+            return lines.length > 0 ? ['', ...lines] : [];
+        })(),
+        ...(() => {
+            const lines = buildMissedCollaborationDiagnosticSummaryLines(params.promptContext?.missedCollaborationDiagnostic);
+            return lines.length > 0 ? ['', ...lines] : [];
+        })(),
         ...buildSkillRuntimePromptLines(params.promptContext),
         ...buildLocalhostGatewayPromptLines(params.promptContext),
         '',

package/dist/context/task-thread-collaboration.d.ts

@@ -0,0 +1,6 @@
+import type { TaskThreadCollaborationContract } from '../types.js';
+export declare function projectTaskThreadCollaborationContract(params: {
+    incomingMessageType?: string;
+    taskThreadContextActive: boolean;
+}): TaskThreadCollaborationContract | undefined;
+export declare function buildTaskThreadCollaborationSummaryLines(contract: TaskThreadCollaborationContract | undefined): string[];

package/dist/context/task-thread-collaboration.js

@@ -0,0 +1,31 @@
+export function projectTaskThreadCollaborationContract(params) {
+    if (!params.taskThreadContextActive) {
+        return undefined;
+    }
+    const turnRole = params.incomingMessageType?.trim() === 'task_assignment'
+        ? 'assignment'
+        : 'continuation';
+    return {
+        source: 'host-projected',
+        turnRole,
+        taskThreadContextActive: true,
+        mainResult: 'ordinary-final-reply-in-thread',
+        auxiliaryRoute: 'optional-auxiliary-send-or-escalation-only',
+        checkIn: 'status-update-intent-only',
+        blockedWork: 'in-thread-disclosure-only',
+    };
+}
+export function buildTaskThreadCollaborationSummaryLines(contract) {
+    if (!contract) {
+        return [];
+    }
+    return [
+        'Shared task-thread collaboration contract for this turn (projection only; not runtime-authoritative truth).',
+        `Thread role: ${contract.turnRole}`,
+        `Active task-thread context: ${contract.taskThreadContextActive ? 'yes' : 'no'}`,
+        'Main task result: return the ordinary final reply in this task thread.',
+        'Auxiliary send or escalation: optional auxiliary route only, never the main completion path.',
+        'Check-in: status-update intent only; no timer, heartbeat, send-route, scheduler, receipt, or recovery authority is implied here.',
+        'Blocked work: disclose the blocker in-thread through the existing in-thread reply path, if one exists; no blocked-state authority or extra control kind is implied here.',
+    ];
+}

package/dist/context/turn-preparation.js

@@ -11,7 +11,13 @@ function providerLabel(provider) {
     return 'Claude';
 }
 function toPromptContext(channelContext, input) {
-    if (!channelContext && !input.collaboration) {
+    if (!channelContext
+        && !input.collaboration
+        && !input.collaborationOutcome
+        && !input.attentionSnapshot
+        && !input.collaborationCapabilities
+        && !input.missedCollaborationDiagnostic
+        && !input.taskThreadCollaborationContract) {
         return undefined;
     }
     return {
@@ -27,6 +33,22 @@ function toPromptContext(channelContext, input) {
             : {}),
         collaborationTurnExecutionId: input.collaboration?.turnExecutionId,
         collaborationTurnMode: input.collaboration?.turnMode,
+        collaborationOutcome: input.collaborationOutcome ?? channelContext?.payload.collaborationOutcome,
+        attentionSnapshot: input.attentionSnapshot ?? channelContext?.payload.attentionSnapshot,
+        ...(() => {
+            const collaborationCapabilities = input.collaborationCapabilities ?? channelContext?.payload.collaborationCapabilities;
+            return collaborationCapabilities ? { collaborationCapabilities } : {};
+        })(),
+        ...(() => {
+            const missedCollaborationDiagnostic = input.missedCollaborationDiagnostic ?? channelContext?.payload.missedCollaborationDiagnostic;
+            return missedCollaborationDiagnostic ? { missedCollaborationDiagnostic } : {};
+        })(),
+        ...(input.taskThreadCollaborationContract || channelContext?.payload.taskThreadCollaborationContract
+            ? {
+                taskThreadCollaborationContract: input.taskThreadCollaborationContract
+                    ?? channelContext?.payload.taskThreadCollaborationContract,
+            }
+            : {}),
         kickoff: input.collaboration?.kickoff,
         protocol: input.collaboration?.protocol,
         grounding: input.collaboration?.grounding,
@@ -65,6 +87,13 @@ export class ProviderTurnPreparer {
                                 && input.collaboration.turnMode !== 'silent-kickoff',
                         }
                         : undefined,
+                    collaborationOutcome: input.collaborationOutcome,
+                    attentionSnapshot: input.attentionSnapshot,
+                    collaborationCapabilities: input.collaborationCapabilities,
+                    missedCollaborationDiagnostic: input.missedCollaborationDiagnostic,
+                    ...(input.taskThreadCollaborationContract
+                        ? { taskThreadCollaborationContract: input.taskThreadCollaborationContract }
+                        : {}),
                     ...(input.incomingMessageType !== undefined
                         ? { incomingMessageType: input.incomingMessageType }
                         : {}),

package/dist/providers/awaiting-user.js

@@ -1,5 +1,17 @@
 export const HOST_CONTROL_PREFIX = '[[BORGEE_CONTROL]] ';
 export const AWAITING_USER_CONTROL_PREFIX = HOST_CONTROL_PREFIX;
+const VALID_ATTENTION_UPDATES = new Set([
+    'follow-channel',
+    'unfollow-channel',
+    'mute-channel',
+    'claim-channel',
+    'claim-task-thread',
+    'unclaim-channel',
+    'unclaim-task-thread',
+]);
+function isProviderAttentionUpdate(value) {
+    return typeof value === 'string' && VALID_ATTENTION_UPDATES.has(value);
+}
 function hasVisibleText(value) {
     return value.trim().length > 0;
 }
@@ -50,13 +62,26 @@ function parseControlPayload(payload) {
     if (typeof record.kind !== 'string') {
         return null;
     }
+    const attentionUpdate = (() => {
+        if (record.attentionUpdate === undefined) {
+            return undefined;
+        }
+        return isProviderAttentionUpdate(record.attentionUpdate) ? record.attentionUpdate : null;
+    })();
+    if (attentionUpdate === null) {
+        return null;
+    }
     if (record.kind === 'continue-to-peer' || record.kind === 'conclude-locally') {
-        return Object.keys(record).length === 1
-            ? { kind: record.kind }
+        return Object.keys(record).every((key) => key === 'kind' || key === 'attentionUpdate')
+            ? {
+                kind: record.kind,
+                ...(attentionUpdate ? { attentionUpdate } : {}),
+            }
             : null;
     }
     if (record.kind === 'start-protocol') {
-        return Object.keys(record).length === 2
+        return attentionUpdate === undefined
+            && Object.keys(record).length === 2
             && typeof record.rounds === 'number'
             && Number.isInteger(record.rounds)
             && record.rounds > 0
@@ -68,7 +93,7 @@ function parseControlPayload(payload) {
     }
     if (record.kind === 'awaiting-user') {
         const keys = Object.keys(record);
-        if (keys.some((key) => key !== 'kind' && key !== 'question' && key !== 'reason')) {
+        if (keys.some((key) => key !== 'kind' && key !== 'question' && key !== 'reason' && key !== 'attentionUpdate')) {
             return null;
         }
         if (typeof record.question !== 'string' || record.question.trim().length === 0) {
@@ -82,8 +107,17 @@ function parseControlPayload(payload) {
             kind: 'awaiting-user',
             question: record.question.trim(),
             ...(typeof record.reason === 'string' ? { reason: record.reason.trim() } : {}),
+            ...(attentionUpdate ? { attentionUpdate } : {}),
         };
     }
+    if (record.kind === 'attention-only') {
+        return Object.keys(record).length === 2 && attentionUpdate
+            ? {
+                kind: 'attention-only',
+                attentionUpdate,
+            }
+            : null;
+    }
     return null;
 }
 export function parseProviderReply(text) {
@@ -98,8 +132,15 @@ export function parseProviderReply(text) {
             controlMalformed: true,
         };
     }
+    const textWithoutFooter = stripTrailingCarriageReturn(match.analyzedText.slice(0, match.removalStart));
+    if (control.kind === 'attention-only' && !hasVisibleText(textWithoutFooter)) {
+        return {
+            text: textWithoutFooter,
+            controlMalformed: true,
+        };
+    }
     return {
-        text: stripTrailingCarriageReturn(match.analyzedText.slice(0, match.removalStart)),
+        text: textWithoutFooter,
         control,
         ...(control.kind === 'awaiting-user'
             ? {

package/dist/providers/codex/project-doc.js

@@ -1,4 +1,8 @@
 import { basename } from 'node:path';
+import { buildAttentionSummaryLines } from '../../context/attention.js';
+import { buildCollaborationCapabilityDeclarationSummaryLines, buildMissedCollaborationDiagnosticSummaryLines, } from '../../context/collaboration-capabilities-diagnostics.js';
+import { buildCollaborationOutcomeSummaryLines } from '../../context/collaboration-outcome.js';
+import { buildTaskThreadCollaborationSummaryLines } from '../../context/task-thread-collaboration.js';
 const PROJECT_DOC_MAX_BYTES = 32 * 1024;
 function buildSkillRuntimeLines(context) {
     if (!context?.skillRuntime || !context.channelContextPayloadPath) {
@@ -47,6 +51,26 @@ export function buildCodexProjectDocument(context) {
                 'That writable task workspace is local to agents-host for the current task thread and does not imply that the target repository has already been checked out there.',
             ]
             : []),
+        ...(() => {
+            const collaborationOutcomeLines = buildCollaborationOutcomeSummaryLines(context?.collaborationOutcome);
+            return collaborationOutcomeLines.length > 0 ? ['', ...collaborationOutcomeLines] : [];
+        })(),
+        ...(() => {
+            const attentionLines = buildAttentionSummaryLines(context?.attentionSnapshot);
+            return attentionLines.length > 0 ? ['', ...attentionLines] : [];
+        })(),
+        ...(() => {
+            const capabilityLines = buildCollaborationCapabilityDeclarationSummaryLines(context?.collaborationCapabilities);
+            return capabilityLines.length > 0 ? ['', ...capabilityLines] : [];
+        })(),
+        ...(() => {
+            const diagnosticLines = buildMissedCollaborationDiagnosticSummaryLines(context?.missedCollaborationDiagnostic);
+            return diagnosticLines.length > 0 ? ['', ...diagnosticLines] : [];
+        })(),
+        ...(() => {
+            const taskThreadLines = buildTaskThreadCollaborationSummaryLines(context?.taskThreadCollaborationContract);
+            return taskThreadLines.length > 0 ? ['', ...taskThreadLines] : [];
+        })(),
         ...(() => {
             const skillRuntimeLines = buildSkillRuntimeLines(context);
             return skillRuntimeLines.length > 0 ? ['', ...skillRuntimeLines] : [];