@borgee/agents-host 0.2.26 → 0.2.28

package/dist/state-paths.d.ts

@@ -11,6 +11,7 @@ export declare function resolveAgentCursorPath(stateRootDir: string, agentId: st
 export declare function resolveSharedProtocolKickoffDecisionPath(stateRootDir: string, channelId: string, anchorMessageId: string): string;
 export declare function resolveSharedProtocolStatusPath(stateRootDir: string, channelId: string, anchorMessageId: string): string;
 export declare function resolveConnectionsStatePath(stateRootDir: string): string;
+export declare function resolveAttentionStatePath(stateRootDir: string, channelId: string): string;
 export declare function resolveAuthorizationAuditPath(stateRootDir: string): string;
 export declare function resolvePreviousAuthorizationAuditPath(stateRootDir: string): string;
 export declare function resolveClaudeSessionMapPath(stateRootDir: string, agentId: string): string;

package/dist/state-paths.js

@@ -110,6 +110,9 @@ export function resolveSharedProtocolStatusPath(stateRootDir, channelId, anchorM
 export function resolveConnectionsStatePath(stateRootDir) {
     return join(stateRootDir, 'connections-state.sqlite');
 }
+export function resolveAttentionStatePath(stateRootDir, channelId) {
+    return join(stateRootDir, 'attention-state', `${encodeSegment(channelId)}.json`);
+}
 export function resolveAuthorizationAuditPath(stateRootDir) {
     return join(stateRootDir, 'authorization-audit.jsonl');
 }

package/dist/types.d.ts

@@ -140,6 +140,83 @@ export interface CollaborationDraftSnapshot {
     finalMessageId?: string;
 }
 export type ProviderCollaborationTurnMode = 'ordinary' | 'silent-kickoff' | 'protocol-managed';
+export type CollaborationOutcomeResponseState = 'responded' | 'blocked' | 'superseded' | 'failed';
+export type CollaborationOutcomeDeliveryState = 'posted' | 'draft-finalized' | 'not-delivered' | 'delivery-failed';
+export type CollaborationOutcomeWakeState = 'waiting' | 'suppressed-agent' | 'resumed-human';
+export interface CollaborationOutcomeBlockedDetails {
+    question: string;
+    reason?: string;
+}
+/**
+ * Shared host-side projection only. This is the latest host-observed snapshot
+ * that adapters may surface back to providers; it is not provider-authoritative
+ * truth about collaboration state or recovery.
+ */
+export interface CollaborationOutcomeSnapshot {
+    source: 'host-observed';
+    responseState: CollaborationOutcomeResponseState;
+    deliveryState: CollaborationOutcomeDeliveryState;
+    wakeState?: CollaborationOutcomeWakeState;
+    blockedDetails?: CollaborationOutcomeBlockedDetails;
+    observedAt: number;
+    turnExecutionId?: string;
+}
+export type AttentionDeliveryMode = 'default' | 'follow' | 'muted';
+export type AttentionClaimState = 'unclaimed' | 'claimed';
+export type AttentionClaimActivation = 'inactive' | 'active' | 'dormant';
+export type AttentionWakeMode = 'current-policy' | 'follow-visible-human' | 'mute-non-mention';
+export type ProviderAttentionUpdate = 'follow-channel' | 'unfollow-channel' | 'mute-channel' | 'claim-channel' | 'claim-task-thread' | 'unclaim-channel' | 'unclaim-task-thread';
+export interface AttentionClaimContext {
+    scope: 'channel' | 'task-thread';
+    taskId: string;
+}
+/**
+ * Shared host-side projection only. This is the latest host-observed snapshot
+ * that adapters may surface back to providers; it is not server-authoritative
+ * truth about delivery policy, fanout, or ownership.
+ */
+export interface AttentionSnapshot {
+    source: 'host-observed';
+    deliveryMode: AttentionDeliveryMode;
+    claimState: AttentionClaimState;
+    claimActivation: AttentionClaimActivation;
+    wakeMode: AttentionWakeMode;
+    observedAt: number;
+    turnExecutionId?: string;
+    claimContext?: AttentionClaimContext;
+}
+export type TaskThreadCollaborationTurnRole = 'assignment' | 'continuation';
+export type TaskThreadMainResultContract = 'ordinary-final-reply-in-thread';
+export type TaskThreadAuxiliaryRouteContract = 'optional-auxiliary-send-or-escalation-only';
+export type TaskThreadCheckInContract = 'status-update-intent-only';
+export type TaskThreadBlockedWorkContract = 'in-thread-disclosure-only';
+/**
+ * Shared host-side projection only. This is a narrow adapter-facing summary of
+ * task-thread collaboration meaning; it is not runtime-authoritative truth
+ * about task ownership, task routes, heartbeat execution, or blocked state.
+ */
+export interface TaskThreadCollaborationContract {
+    source: 'host-projected';
+    turnRole: TaskThreadCollaborationTurnRole;
+    taskThreadContextActive: true;
+    mainResult: TaskThreadMainResultContract;
+    auxiliaryRoute: TaskThreadAuxiliaryRouteContract;
+    checkIn: TaskThreadCheckInContract;
+    blockedWork: TaskThreadBlockedWorkContract;
+}
+export interface CollaborationCapabilityDeclaration {
+    collaborationOutcome?: true;
+    attentionSnapshot?: true;
+    taskThreadCollaborationContract?: true;
+    missedCollaborationDiagnostic?: true;
+    recoveryExplanation?: 'runtime-local-only';
+}
+export type MissedCollaborationDiagnosticStage = 'delivery' | 'wake' | 'response';
+export type MissedCollaborationDiagnosticReason = 'delivery-failed' | 'not-delivered' | 'wake-suppressed-attention-policy' | 'blocked-awaiting-user';
+export interface MissedCollaborationDiagnostic {
+    stage: MissedCollaborationDiagnosticStage;
+    reason: MissedCollaborationDiagnosticReason;
+}
 export interface ProviderCollaborationContext {
     enabled: boolean;
     turnExecutionId?: string;
@@ -158,6 +235,11 @@ export interface ProviderInput {
     incomingEventKind?: string;
     incomingMessageType?: string;
     collaboration?: ProviderCollaborationContext;
+    collaborationOutcome?: CollaborationOutcomeSnapshot;
+    attentionSnapshot?: AttentionSnapshot;
+    taskThreadCollaborationContract?: TaskThreadCollaborationContract;
+    collaborationCapabilities?: CollaborationCapabilityDeclaration;
+    missedCollaborationDiagnostic?: MissedCollaborationDiagnostic;
 }
 export interface ProviderProtocolContext {
     anchorMessageId: string;
@@ -210,6 +292,11 @@ export interface PreparedPromptContext {
     gatewayAuthPath?: string;
     collaborationTurnExecutionId?: string;
     collaborationTurnMode?: ProviderCollaborationTurnMode;
+    collaborationOutcome?: CollaborationOutcomeSnapshot;
+    attentionSnapshot?: AttentionSnapshot;
+    taskThreadCollaborationContract?: TaskThreadCollaborationContract;
+    collaborationCapabilities?: CollaborationCapabilityDeclaration;
+    missedCollaborationDiagnostic?: MissedCollaborationDiagnostic;
     kickoff?: ProviderProtocolKickoffContext;
     protocol?: ProviderProtocolContext;
     grounding?: ProviderTurnGroundingContext;
@@ -234,16 +321,22 @@ export interface ProviderAwaitingUser {
     question: string;
     reason?: string;
 }
-export type ProviderTurnControl = {
+export interface ProviderTurnControlBase {
+    attentionUpdate?: ProviderAttentionUpdate;
+}
+export type ProviderTurnControl = ({
     kind: 'continue-to-peer';
-} | {
+} & ProviderTurnControlBase) | ({
     kind: 'conclude-locally';
-} | {
+} & ProviderTurnControlBase) | {
     kind: 'start-protocol';
     rounds: number;
 } | ({
     kind: 'awaiting-user';
-} & ProviderAwaitingUser);
+} & ProviderAwaitingUser & ProviderTurnControlBase) | ({
+    kind: 'attention-only';
+    attentionUpdate: ProviderAttentionUpdate;
+} & ProviderTurnControlBase);
 export interface ProviderReply {
     text: string;
     awaitingUser?: ProviderAwaitingUser;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@borgee/agents-host",
-  "version": "0.2.26",
+  "version": "0.2.28",
   "private": false,
   "publishConfig": {
     "access": "public"