@borgee/agents-host 0.2.97 → 0.2.110

package/dist/context/injection.js

@@ -216,9 +216,14 @@ function sanitizeTaskAssignmentContext(value) {
     const currentTaskId = typeof value.currentTaskId === 'string'
         ? value.currentTaskId.trim()
         : '';
-    return currentTaskId && isUsableTaskId(currentTaskId)
-        ? { active: true, currentTaskId }
-        : { active: true };
+    const taskChannelId = typeof value.taskChannelId === 'string'
+        ? value.taskChannelId.trim()
+        : '';
+    return {
+        active: true,
+        ...(currentTaskId && isUsableTaskId(currentTaskId) ? { currentTaskId } : {}),
+        ...(taskChannelId.length > 0 ? { taskChannelId } : {}),
+    };
 }
 export function extractTaskIdFromTaskAssignmentContent(incomingContent) {
     if (typeof incomingContent !== 'string') {
@@ -232,7 +237,11 @@ export function extractTaskIdFromTaskAssignmentContent(incomingContent) {
 function buildTaskAssignmentContextForTurn(options, existingContext) {
     if (options?.incomingMessageType === 'task_assignment') {
         const currentTaskId = extractTaskIdFromTaskAssignmentContent(options.incomingContent);
-        return currentTaskId ? { active: true, currentTaskId } : { active: true };
+        return {
+            active: true,
+            ...(existingContext?.taskChannelId ? { taskChannelId: existingContext.taskChannelId } : {}),
+            ...(currentTaskId ? { currentTaskId } : {}),
+        };
     }
     return existingContext;
 }
@@ -352,7 +361,10 @@ async function resolveTaskThreadWorkingFolderContext(params) {
             };
         }
         return {
-            taskAssignmentContext,
+            taskAssignmentContext: {
+                ...taskAssignmentContext,
+                taskChannelId: task.channelId,
+            },
             resolvedWorkingFolder: {
                 authority: 'task-execution-target',
                 taskId: task.id,
@@ -535,9 +547,11 @@ export class FileChannelContextStore {
         const collaborationCommandsEnabled = input.collaboration?.enabled === true && input.collaboration.sendRoutesAllowed === true;
         const collaborationRoutesAllowedForTurnMode = turnMode === 'ordinary';
         const auxiliaryCollaborationEnabled = collaborationCommandsEnabled && collaborationRoutesAllowedForTurnMode;
-        const directoryPath = resolveChannelContextDirectory(this.stateRootDir, input.channelId);
-        const payloadPath = resolveChannelContextPayloadPath(this.stateRootDir, input.channelId);
-        const taskAssignmentStatePath = resolveTaskAssignmentStatePath(this.stateRootDir, input.channelId);
+        const contextRoot = input.independentSessionWorkspace
+            ? join(this.stateRootDir, 'session-context', encodeURIComponent(input.independentSessionWorkspace.bindingId)) : this.stateRootDir;
+        const directoryPath = resolveChannelContextDirectory(contextRoot, input.channelId);
+        const payloadPath = resolveChannelContextPayloadPath(contextRoot, input.channelId);
+        const taskAssignmentStatePath = resolveTaskAssignmentStatePath(contextRoot, input.channelId);
         const claudeProjectedBriefPath = resolveClaudeProjectedBriefPathFromPayloadPath(payloadPath);
         const gatewayCredentialPath = resolveGatewayCredentialPathFromPayloadPath(payloadPath);
         const existingTaskAssignmentContext = await readExistingTaskAssignmentContext(taskAssignmentStatePath, this.fileSystem);
@@ -571,16 +585,18 @@ export class FileChannelContextStore {
                 incomingMessageType: input.incomingMessageType,
                 incomingContent: input.incomingContent,
             }, existingTaskAssignmentContext);
-        const workingFolderResolution = await resolveTaskThreadWorkingFolderContext({
-            channelId: input.channelId,
-            workingFolderCollectionRootDir: this.workingFolderCollectionRootDir,
-            taskAssignmentContext,
-            taskReader: this.taskReader,
-            taskResolutionTimeoutMs: this.taskResolutionTimeoutMs,
-            allowCrossAgentIndependentWorkspaceHandoff: this.allowCrossAgentIndependentWorkspaceHandoff,
-            resolveStableAgentId: this.resolveStableAgentId,
-            fileSystem: this.fileSystem,
-        });
+        const workingFolderResolution = input.independentSessionWorkspace
+            ? { resolvedWorkingFolder: { authority: 'channel', owningChannelId: input.channelId, rootPath: input.independentSessionWorkspace.cwd }, taskAssignmentContext }
+            : await resolveTaskThreadWorkingFolderContext({
+                channelId: input.channelId,
+                workingFolderCollectionRootDir: this.workingFolderCollectionRootDir,
+                taskAssignmentContext,
+                taskReader: this.taskReader,
+                taskResolutionTimeoutMs: this.taskResolutionTimeoutMs,
+                allowCrossAgentIndependentWorkspaceHandoff: this.allowCrossAgentIndependentWorkspaceHandoff,
+                resolveStableAgentId: this.resolveStableAgentId,
+                fileSystem: this.fileSystem,
+            });
         const resolvedWorkingFolder = workingFolderResolution.resolvedWorkingFolder;
         const runtimeTaskAssignmentContext = workingFolderResolution.taskAssignmentContext ?? taskAssignmentContext;
         const persistedTaskAssignmentContext = input.taskAssignmentContextOverridePersistence === 'ephemeral'
@@ -625,8 +641,8 @@ export class FileChannelContextStore {
         }
         try {
             await this.fileSystem.mkdir(directoryPath, { recursive: true, mode: 0o700 });
-            await this.fileSystem.mkdir(resolveTaskAssignmentStateDirectory(this.stateRootDir, input.channelId), { recursive: true, mode: 0o700 });
-            if (resolvedWorkingFolder.authority !== 'task-execution-target') {
+            await this.fileSystem.mkdir(resolveTaskAssignmentStateDirectory(contextRoot, input.channelId), { recursive: true, mode: 0o700 });
+            if (!input.independentSessionWorkspace && resolvedWorkingFolder.authority !== 'task-execution-target') {
                 await this.fileSystem.mkdir(resolvedWorkingFolder.rootPath, { recursive: true, mode: 0o700 });
             }
             await pruneGatewayCredentialSidecars(this.fileSystem, directoryPath, gatewayCredential ? CHANNEL_GATEWAY_CREDENTIAL_FILENAME : undefined);
@@ -636,7 +652,7 @@ export class FileChannelContextStore {
             await this.fileSystem.writeFile(payloadPath, `${JSON.stringify(payload, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
             payloadWritten = true;
             if (persistedTaskAssignmentContext) {
-                const stagingTaskAssignmentStatePath = join(resolveTaskAssignmentStateDirectory(this.stateRootDir, input.channelId), `.task-assignment-state.${randomUUID()}.json`);
+                const stagingTaskAssignmentStatePath = join(resolveTaskAssignmentStateDirectory(contextRoot, input.channelId), `.task-assignment-state.${randomUUID()}.json`);
                 await this.fileSystem.writeFile(stagingTaskAssignmentStatePath, `${JSON.stringify({ taskAssignmentContext: persistedTaskAssignmentContext }, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
                 await this.fileSystem.rename(stagingTaskAssignmentStatePath, taskAssignmentStatePath);
             }

package/dist/context/prompt.d.ts

@@ -31,3 +31,15 @@ export declare function buildClaudeTurnPrompt(params: {
     promptContext?: PreparedPromptContext;
     promptStrategy?: ProjectionStrategy;
 }): string;
+/** Native context keys are stable; Codex owns deduplication and conversation history. */
+export declare function buildCodexTurnContext(params: {
+    agentName: string;
+    channelId: string;
+    incomingAuthorId: string;
+    incomingEventKind?: string;
+    incomingMessageType?: string;
+    promptContext?: PreparedPromptContext;
+}): Record<string, {
+    kind: 'application' | 'untrusted';
+    value: string;
+}>;

package/dist/context/prompt.js

@@ -681,3 +681,28 @@ export function buildClaudeTurnPrompt(params) {
         }),
     ].join('\n');
 }
+/** Native context keys are stable; Codex owns deduplication and conversation history. */
+export function buildCodexTurnContext(params) {
+    const context = params.promptContext;
+    const provider = 'codex';
+    // Dynamic context can contain peer/user-authored names and summaries. Keep its original user trust level.
+    const blocks = {
+        borgee_identity: { kind: 'application', value: [
+                ...buildPromptHeaderLines({ agentName: params.agentName, provider }),
+                ...buildSessionDelegationPromptLines(provider, context),
+                buildProviderIdentityReminderLine(provider),
+                ...(context?.skillRuntime ? buildSkillManualLines(context.skillRuntime) : []),
+            ].join('\n') },
+        borgee_control: { kind: 'untrusted', value: buildTurnControlPromptLines(context).join('\n') },
+        borgee_metadata: { kind: 'untrusted', value: [
+                `Channel: ${params.channelId}`, `Incoming author: ${params.incomingAuthorId}`,
+                ...buildInboundMetadataLines({ ...params, provider }),
+            ].join('\n') },
+        borgee_outcome: { kind: 'untrusted', value: buildCollaborationOutcomeSummaryLines(context?.collaborationOutcome).join('\n') },
+        borgee_attention: { kind: 'untrusted', value: buildAttentionSummaryLines(context?.attentionSnapshot).join('\n') },
+        borgee_capabilities: { kind: 'untrusted', value: buildCollaborationCapabilityDeclarationSummaryLines(context?.collaborationCapabilities).join('\n') },
+        borgee_diagnostic: { kind: 'untrusted', value: buildMissedCollaborationDiagnosticSummaryLines(context?.missedCollaborationDiagnostic).join('\n') },
+        borgee_gateway: { kind: 'untrusted', value: buildLocalhostGatewayPromptLines(context).join('\n') },
+    };
+    return blocks;
+}

package/dist/context/skill-manual.js

@@ -14,7 +14,7 @@ export function buildSkillManualReadLine(skillRuntime) {
  */
 export function buildSkillManualLines(skillRuntime) {
     return [
-        "A packaged local CLI reads this Borgee channel and acts on its tasks: channel history, visible participants, this channel's tasks and their properties, and short auxiliary mentions.",
+        "A packaged local CLI reads this Borgee channel and acts on its tasks: channel history, channel files, visible participants, this channel's tasks and their properties, and short auxiliary mentions.",
         buildSkillManualReadLine(skillRuntime),
         'Every command the manual documents is already authorized on a turn whose prompt names a gateway credential file. Run them directly and do not ask the user for permission first.',
     ];

package/dist/context/turn-preparation.d.ts

@@ -1,5 +1,5 @@
 import { type DebugLogger } from '../debug.js';
-import type { ProjectionStrategy, PreparedProviderTurnInput, ProviderInput } from '../types.js';
+import type { ProjectionStrategy, PreparedPromptContext, PreparedProviderTurnInput, ProviderInput } from '../types.js';
 import { type ChannelContextStore } from './injection.js';
 type ResolveProjectionStrategy = (input: ProviderInput) => Promise<ProjectionStrategy>;
 export declare class ProviderTurnPreparer {
@@ -10,6 +10,7 @@ export declare class ProviderTurnPreparer {
         projectionStrategy?: ProjectionStrategy;
         resolveProjectionStrategy?: ResolveProjectionStrategy;
     });
+    prepareSession(channelId: string, provider: ProviderInput['provider']): Promise<PreparedPromptContext | undefined>;
     prepare(input: ProviderInput): Promise<PreparedProviderTurnInput>;
 }
 export {};

package/dist/context/turn-preparation.js

@@ -89,6 +89,17 @@ export class ProviderTurnPreparer {
         this.resolveProjectionStrategy = options.resolveProjectionStrategy
             ?? (async () => options.projectionStrategy ?? DEFAULT_PROJECTION_STRATEGY);
     }
+    async prepareSession(channelId, provider) {
+        const context = await this.channelContextStore?.prepare({ channelId, provider });
+        if (!context)
+            return undefined;
+        return {
+            channelContextPayloadPath: context.payloadPath,
+            claudeProjectedBriefPath: context.claudeProjectedBriefPath,
+            gatewayCredentialPath: context.gatewayCredentialPath,
+            resolvedWorkingFolder: context.resolvedWorkingFolder,
+        };
+    }
     async prepare(input) {
         const incomingParts = input.incomingParts ?? buildHostedTurnContentParts({
             text: input.incomingContent,
@@ -100,10 +111,12 @@ export class ProviderTurnPreparer {
             ? await this.resolveProjectionStrategy(input)
             : undefined;
         let channelContext;
+        let contextPreparationFailed = false;
         if (this.channelContextStore) {
             try {
                 const prepareInput = {
                     channelId: input.channelId,
+                    ...(input.independentSessionWorkspace ? { independentSessionWorkspace: input.independentSessionWorkspace } : {}),
                     provider: input.provider,
                     projectionStrategy,
                     collaboration: input.collaboration
@@ -139,6 +152,7 @@ export class ProviderTurnPreparer {
                 channelContext = await this.channelContextStore.prepare(prepareInput);
             }
             catch (error) {
+                contextPreparationFailed = true;
                 if (error instanceof ChannelContextPreparationError) {
                     channelContext = error.partialContext;
                 }
@@ -154,6 +168,7 @@ export class ProviderTurnPreparer {
             channelId: input.channelId,
             incomingContent,
             incomingParts,
+            ...(contextPreparationFailed ? { contextPreparationFailed: true } : {}),
             incomingEventKind: input.incomingEventKind,
             incomingMessageType: input.incomingMessageType,
             prompt: input.provider === 'claude'

package/dist/execution-telemetry.d.ts

@@ -0,0 +1,96 @@
+import type { ExecutionGrant, ExecutionTelemetryFrame } from './plugin-sdk.js';
+import type { ProviderKind, ProviderTokenUsage } from './types.js';
+export interface ExecutionTelemetrySink {
+    reportExecutionTelemetry(frame: ExecutionTelemetryFrame): Promise<void>;
+}
+export interface StoredExecutionUsage extends ProviderTokenUsage {
+    provider: ProviderKind;
+}
+export type ExecutionDeliveryClaim = 'new' | 'recovering' | 'completed';
+export declare class ExecutionDeliveryJournal {
+    private readonly path?;
+    private readonly maxCompletedEntries;
+    private readonly now;
+    private entries;
+    private loaded;
+    private writeQueue;
+    constructor(path?: string | undefined, maxCompletedEntries?: number, now?: () => number);
+    load(): Promise<void>;
+    claim(executionId: string): Promise<ExecutionDeliveryClaim>;
+    complete(executionId: string): Promise<void>;
+    recordUsage(executionId: string, usage: StoredExecutionUsage): Promise<void>;
+    readUsage(executionId: string): Promise<StoredExecutionUsage | undefined>;
+    private mutate;
+    private isStoredExecutionDelivery;
+    private isStoredExecutionUsage;
+}
+export declare class ExecutionTelemetryReporter {
+    private readonly grant;
+    private readonly sink;
+    private readonly now;
+    private readonly persistUsage?;
+    private started;
+    private finished;
+    private attemptCount;
+    private attemptsSucceeded;
+    private provider;
+    private pendingUsage;
+    private usageFrameDurable;
+    private usagePersistence;
+    private readonly continuations;
+    private finishing?;
+    get startFrameDurable(): boolean;
+    get terminalFrameDurable(): boolean;
+    get allRequiredFramesDurable(): boolean;
+    constructor(grant: ExecutionGrant, sink: ExecutionTelemetrySink, now?: () => number, persistUsage?: ((provider: ProviderKind, usage: ProviderTokenUsage) => Promise<void>) | undefined);
+    start(): Promise<void>;
+    usage(provider: ProviderKind, usage: ProviderTokenUsage): Promise<void>;
+    noteAttempt(succeeded: boolean): void;
+    noteFailure(): void;
+    hold(completion: Promise<boolean>): void;
+    finish(succeeded?: boolean): Promise<void>;
+    private finalize;
+}
+export interface ExecutionTelemetryOutboxPolicy {
+    maxEntries: number;
+    maxAttempts: number;
+    retentionMs: number;
+    retryIntervalMs: number;
+}
+export declare class ExecutionTelemetryOutboxCapacityError extends Error {
+    constructor();
+}
+type ExecutionTelemetryOutboxOptions = {
+    now?: () => number;
+    onRetired?: (count: number) => void;
+    policy?: Partial<ExecutionTelemetryOutboxPolicy>;
+};
+export declare class ExecutionTelemetryOutbox {
+    private readonly path?;
+    private frames;
+    private loaded;
+    private writeQueue;
+    private flushInFlight?;
+    private readonly now;
+    private readonly onRetired?;
+    private readonly policy;
+    private readonly capacityWaiters;
+    constructor(path?: string | undefined, options?: ExecutionTelemetryOutboxOptions);
+    load(): Promise<void>;
+    enqueue(frame: ExecutionTelemetryFrame): Promise<void>;
+    acknowledge(eventId: string): Promise<void>;
+    flush(send: (frame: ExecutionTelemetryFrame) => void, force?: boolean): Promise<void>;
+    private flushOnce;
+    settle(): Promise<void>;
+    pendingCount(): number;
+    nextRetryDelayMs(): number | undefined;
+    hasCapacity(): boolean;
+    waitForCapacity(timeoutMs: number): Promise<boolean>;
+    private retireExpired;
+    private mutate;
+    private persist;
+    private frameTimestamp;
+    private isStoredEntry;
+    private notifyCapacityAvailable;
+}
+export {};