@borgee/agents-host 0.2.26 → 0.2.29

package/dist/compatibility-gates.d.ts

@@ -6,10 +6,15 @@ 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";
 export declare const COMPATIBILITY_GATES_ENV = "AGENTS_HOST_INTERNAL_COMPATIBILITY_GATES";
+export declare const INTERNAL_DISABLED_COMPATIBILITY_GATES_ENV = "AGENTS_HOST_INTERNAL_DISABLED_COMPATIBILITY_GATES";
 export declare const INTERNAL_POLICY_MODE_ENV = "AGENTS_HOST_INTERNAL_POLICY_MODE";
 export declare const INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV = "AGENTS_HOST_INTERNAL_PROVIDER_IMPLEMENTATIONS";
 export declare const MANAGED_RUNTIME_SETTINGS_SCHEMA_VERSION = 1;
@@ -23,8 +28,10 @@ export interface ManagedRuntimeSettingsSnapshot {
     providerImplementationOverrides: string[];
     internalPolicyMode: InternalPolicyMode;
 }
+export declare const DEFAULT_INTERNAL_COMPATIBILITY_GATES: readonly string[];
 export declare function parseCompatibilityGates(rawValue: string | undefined): ReadonlySet<string>;
-export declare function resolveInternalCompatibilityGates(): ReadonlySet<string>;
+export declare function resolveInternalCompatibilityGates(env?: NodeJS.ProcessEnv): ReadonlySet<string>;
+export declare function resolveDisabledDefaultCompatibilityGates(compatibilityGates: Iterable<string>): string[];
 export declare function normalizeInternalProviderImplementationOverrides(rawValue: string | undefined): string[];
 export declare function parseInternalProviderImplementationOverrides(rawValue: string | undefined): InternalProviderImplementationOverrides;
 export declare function resolveManagedRuntimeProviderImplementationOverrides(env?: NodeJS.ProcessEnv, compatibilityGates?: string[]): string[];

package/dist/compatibility-gates.js

@@ -7,14 +7,34 @@ 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';
 export const COMPATIBILITY_GATES_ENV = 'AGENTS_HOST_INTERNAL_COMPATIBILITY_GATES';
+export const INTERNAL_DISABLED_COMPATIBILITY_GATES_ENV = 'AGENTS_HOST_INTERNAL_DISABLED_COMPATIBILITY_GATES';
 export const INTERNAL_POLICY_MODE_ENV = 'AGENTS_HOST_INTERNAL_POLICY_MODE';
 export const INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV = 'AGENTS_HOST_INTERNAL_PROVIDER_IMPLEMENTATIONS';
 export const MANAGED_RUNTIME_SETTINGS_SCHEMA_VERSION = 1;
 const VALID_PROVIDER_IMPLEMENTATION_ENTRIES = '"claude:v1", "claude:v2", "copilot:v1", or "copilot:v2"';
+export const DEFAULT_INTERNAL_COMPATIBILITY_GATES = Object.freeze([
+    CLAUDE_PROVIDER_V2_COMPATIBILITY_GATE,
+    COLLABORATION_CAPABILITIES_DIAGNOSTICS_COMPATIBILITY_GATE,
+    COLLABORATION_OUTCOME_MODEL_COMPATIBILITY_GATE,
+    CONNECTIONS_STATE_LAYER_COMPATIBILITY_GATE,
+    CONTEXT_INJECTION_COMPATIBILITY_GATE,
+    CODEX_PROVIDER_COMPATIBILITY_GATE,
+    COPILOT_PROVIDER_V2_COMPATIBILITY_GATE,
+    LOCALHOST_GATEWAY_COMPATIBILITY_GATE,
+    MANAGED_RUNTIME_CONVERGENCE_COMPATIBILITY_GATE,
+    POLICY_AUDIT_ENFORCEMENT_COMPATIBILITY_GATE,
+    SKILL_RUNTIME_COMPATIBILITY_GATE,
+    TASK_THREAD_COLLABORATION_CONTRACT_COMPATIBILITY_GATE,
+    TOKEN_BINDING_COMPATIBILITY_GATE,
+]);
 const PROVIDER_IMPLEMENTATION_COMPATIBILITY_GATES = {
     claude: CLAUDE_PROVIDER_V2_COMPATIBILITY_GATE,
     copilot: COPILOT_PROVIDER_V2_COMPATIBILITY_GATE,
@@ -46,8 +66,19 @@ export function parseCompatibilityGates(rawValue) {
     }
     return gates;
 }
-export function resolveInternalCompatibilityGates() {
-    return parseCompatibilityGates(process.env[COMPATIBILITY_GATES_ENV]);
+export function resolveInternalCompatibilityGates(env = process.env) {
+    const compatibilityGates = new Set(DEFAULT_INTERNAL_COMPATIBILITY_GATES);
+    for (const gate of parseCompatibilityGates(env[COMPATIBILITY_GATES_ENV])) {
+        compatibilityGates.add(gate);
+    }
+    for (const gate of parseCompatibilityGates(env[INTERNAL_DISABLED_COMPATIBILITY_GATES_ENV])) {
+        compatibilityGates.delete(gate);
+    }
+    return compatibilityGates;
+}
+export function resolveDisabledDefaultCompatibilityGates(compatibilityGates) {
+    const enabledGates = new Set(compatibilityGates);
+    return DEFAULT_INTERNAL_COMPATIBILITY_GATES.filter((gate) => !enabledGates.has(gate));
 }
 export function normalizeInternalProviderImplementationOverrides(rawValue) {
     if (!rawValue || rawValue.trim().length === 0) {
@@ -91,11 +122,20 @@ export function resolveManagedRuntimeProviderImplementationOverrides(env = proce
     });
 }
 export function resolveManagedRuntimeCompatibilityGates(env = process.env) {
-    const compatibilityGates = new Set(parseCompatibilityGates(env[COMPATIBILITY_GATES_ENV]));
+    const compatibilityGates = new Set(resolveInternalCompatibilityGates(env));
+    const explicitlyEnabledGates = parseCompatibilityGates(env[COMPATIBILITY_GATES_ENV]);
     if (compatibilityGates.has(MANAGED_RUNTIME_CONVERGENCE_COMPATIBILITY_GATE)) {
         compatibilityGates.add(CONNECTIONS_STATE_LAYER_COMPATIBILITY_GATE);
         compatibilityGates.add(TOKEN_BINDING_COMPATIBILITY_GATE);
     }
+    else {
+        if (!explicitlyEnabledGates.has(CONNECTIONS_STATE_LAYER_COMPATIBILITY_GATE)) {
+            compatibilityGates.delete(CONNECTIONS_STATE_LAYER_COMPATIBILITY_GATE);
+        }
+        if (!explicitlyEnabledGates.has(TOKEN_BINDING_COMPATIBILITY_GATE)) {
+            compatibilityGates.delete(TOKEN_BINDING_COMPATIBILITY_GATE);
+        }
+    }
     return sortUniqueStrings(compatibilityGates);
 }
 export function resolveInternalPolicyMode(gateEnabled, env = process.env) {

package/dist/config.js

@@ -1,5 +1,5 @@
 import { resolveSingleAgentStateRoot } from './state-paths.js';
-import { CODEX_PROVIDER_COMPATIBILITY_GATE, COMPATIBILITY_GATES_ENV, parseCompatibilityGates, } from './compatibility-gates.js';
+import { CODEX_PROVIDER_COMPATIBILITY_GATE, resolveInternalCompatibilityGates, } from './compatibility-gates.js';
 const MAX_TIMER_DELAY_MS = 2_147_483_647;
 export const MAX_COPILOT_SESSION_TTL_MINUTES = MAX_TIMER_DELAY_MS / 60_000;
 export const DEFAULT_COPILOT_SESSION_TTL_MINUTES = 2 * 24 * 60;
@@ -69,9 +69,9 @@ export function assertProviderCompatibility(provider, sourceLabel, env = process
     if (provider !== 'codex') {
         return;
     }
-    const compatibilityGates = parseCompatibilityGates(env[COMPATIBILITY_GATES_ENV]);
+    const compatibilityGates = resolveInternalCompatibilityGates(env);
     if (!compatibilityGates.has(CODEX_PROVIDER_COMPATIBILITY_GATE)) {
-        throw new Error(`${sourceLabel}: provider "codex" requires ${COMPATIBILITY_GATES_ENV} to include ${CODEX_PROVIDER_COMPATIBILITY_GATE}`);
+        throw new Error(`${sourceLabel}: provider "codex" requires the shipped ${CODEX_PROVIDER_COMPATIBILITY_GATE} path to remain enabled`);
     }
 }
 export function resolveProviderCommandConfig(overrides = {}) {

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 }
                         : {}),