@borgee/agents-host 0.2.35 → 0.2.56

package/dist/context/resolved-workspace.js

@@ -0,0 +1,64 @@
+function buildWorkspaceRootLine(context) {
+    const resolvedWorkspace = context.resolvedWorkspace;
+    if (!resolvedWorkspace) {
+        return undefined;
+    }
+    if (resolvedWorkspace.authority === 'task') {
+        return `Writable task-isolated workspace root for this task thread: ${resolvedWorkspace.rootPath}.`;
+    }
+    if (context.taskAssignmentContext?.active === true) {
+        return `Writable workspace root inherited from this task thread's channel: ${resolvedWorkspace.rootPath}.`;
+    }
+    return `Writable workspace root for this channel: ${resolvedWorkspace.rootPath}.`;
+}
+function buildWorkspaceModeLine(context) {
+    if (context.taskAssignmentContext?.active !== true || !context.resolvedWorkspace) {
+        return undefined;
+    }
+    if (context.resolvedWorkspace.authority === 'task') {
+        return 'This task thread runs in a task-isolated workspace instead of inheriting the channel workspace.';
+    }
+    return 'This task thread inherits the channel workspace rather than using a task-isolated workspace.';
+}
+function buildWorkspaceLocalityLine(context) {
+    if (!context.resolvedWorkspace) {
+        return undefined;
+    }
+    if (context.resolvedWorkspace.authority === 'task') {
+        return 'This writable workspace is local to agents-host for this task thread. It does not imply that the target repository has already been checked out there.';
+    }
+    if (context.taskAssignmentContext?.active === true) {
+        return 'This writable workspace is local to agents-host for this task thread because the task inherits its channel workspace. It does not imply that the target repository has already been checked out there.';
+    }
+    return 'This writable workspace is local to agents-host for this channel. It does not imply that the target repository has already been checked out there.';
+}
+function buildCopilotCwdLine(context) {
+    if (!context.resolvedWorkspace) {
+        return undefined;
+    }
+    if (context.resolvedWorkspace.authority === 'task') {
+        return 'GitHub Copilot runs this turn with that task-isolated workspace as its real cwd.';
+    }
+    if (context.taskAssignmentContext?.active === true) {
+        return 'GitHub Copilot runs this turn with that inherited channel workspace as its real cwd.';
+    }
+    return 'GitHub Copilot runs this turn with that workspace as its real cwd.';
+}
+export function buildResolvedWorkspaceGuidanceLines(context, provider) {
+    if (!context?.resolvedWorkspace) {
+        return [];
+    }
+    const lines = [buildWorkspaceRootLine(context), buildWorkspaceModeLine(context)]
+        .filter((line) => line != null);
+    if (provider === 'copilot') {
+        const copilotCwdLine = buildCopilotCwdLine(context);
+        if (copilotCwdLine) {
+            lines.push(copilotCwdLine);
+        }
+    }
+    const localityLine = buildWorkspaceLocalityLine(context);
+    if (localityLine) {
+        lines.push(localityLine);
+    }
+    return lines;
+}

package/dist/context/skill-manual.d.ts

@@ -0,0 +1,14 @@
+import type { SkillRuntimeBootstrapMetadata } from '../types.js';
+export declare function buildSkillManualReadLine(skillRuntime: SkillRuntimeBootstrapMetadata): string;
+/**
+ * What every model-facing surface says about the packaged CLI: what it is, where its manual is, and
+ * that the manual has to be opened before acting. Nothing else about the CLI is stated on a host
+ * surface — the manual is self-contained, so the invocation grammar, the command inventory, the
+ * limits and the credential-file rules have one home that cannot drift from the implementations.
+ *
+ * The authorization sentence is written against the credential file rather than against "this turn"
+ * because the surfaces disagree about scope: the per-turn prompt is turn-scoped while Claude's
+ * session append and Codex's projected document are session-scoped, and only the per-turn prompt
+ * knows whether a credential file exists.
+ */
+export declare function buildSkillManualLines(skillRuntime: SkillRuntimeBootstrapMetadata): string[];

package/dist/context/skill-manual.js

@@ -0,0 +1,21 @@
+export function buildSkillManualReadLine(skillRuntime) {
+    return `Read its manual at ${skillRuntime.skillMarkdownPath} before you act on this channel; it defines both the session-level coordination and delegation contract and the CLI invocation.`;
+}
+/**
+ * What every model-facing surface says about the packaged CLI: what it is, where its manual is, and
+ * that the manual has to be opened before acting. Nothing else about the CLI is stated on a host
+ * surface — the manual is self-contained, so the invocation grammar, the command inventory, the
+ * limits and the credential-file rules have one home that cannot drift from the implementations.
+ *
+ * The authorization sentence is written against the credential file rather than against "this turn"
+ * because the surfaces disagree about scope: the per-turn prompt is turn-scoped while Claude's
+ * session append and Codex's projected document are session-scoped, and only the per-turn prompt
+ * knows whether a credential file exists.
+ */
+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.",
+        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,9 +1,15 @@
 import { type DebugLogger } from '../debug.js';
-import type { PreparedProviderTurnInput, ProviderInput } from '../types.js';
+import type { ProjectionStrategy, PreparedProviderTurnInput, ProviderInput } from '../types.js';
 import { type ChannelContextStore } from './injection.js';
+type ResolveProjectionStrategy = (input: ProviderInput) => Promise<ProjectionStrategy>;
 export declare class ProviderTurnPreparer {
     private readonly channelContextStore?;
     private readonly logger;
-    constructor(channelContextStore?: ChannelContextStore | undefined, logger?: DebugLogger);
+    private readonly resolveProjectionStrategy;
+    constructor(channelContextStore?: ChannelContextStore | undefined, logger?: DebugLogger, options?: {
+        projectionStrategy?: ProjectionStrategy;
+        resolveProjectionStrategy?: ResolveProjectionStrategy;
+    });
     prepare(input: ProviderInput): Promise<PreparedProviderTurnInput>;
 }
+export {};

package/dist/context/turn-preparation.js

@@ -1,6 +1,8 @@
 import { HostLogger, summarizeError } from '../debug.js';
-import { ChannelContextPreparationError, } from './injection.js';
-import { buildPrompt } from './prompt.js';
+import { DEFAULT_PROJECTION_STRATEGY } from '../projection-strategy-values.js';
+import { buildHostedIncomingContentText, buildHostedTurnContentParts } from '../hosted-turn-content.js';
+import { buildRuntimeSurfaceForTurn, ChannelContextPreparationError, } from './injection.js';
+import { buildClaudeSessionPromptAppend, buildClaudeTurnPrompt, buildPrompt } from './prompt.js';
 function providerLabel(provider) {
     if (provider === 'copilot') {
         return 'Copilot';
@@ -15,26 +17,36 @@ function toPromptContext(channelContext, input) {
         && !input.collaboration
         && !input.collaborationOutcome
         && !input.attentionSnapshot
+        && !input.compactionSnapshot
         && !input.collaborationCapabilities
         && !input.missedCollaborationDiagnostic
         && !input.taskThreadCollaborationContract) {
         return undefined;
     }
+    const runtimeSurface = channelContext?.payload.runtimeSurface ?? buildRuntimeSurfaceForTurn({
+        localhostGateway: channelContext?.payload.localhostGateway ?? channelContext?.localhostGateway,
+        collaboration: input.collaboration,
+        taskAssignmentContext: channelContext?.payload.taskAssignmentContext,
+    });
     return {
         ...(channelContext
             ? {
                 channelContextPayloadPath: channelContext.payloadPath,
-                gatewayAuthPath: channelContext.gatewayAuthPath,
+                claudeProjectedBriefPath: channelContext.claudeProjectedBriefPath,
+                claudeProjectedBriefHash: channelContext.claudeProjectedBriefHash,
+                gatewayCredentialPath: channelContext.gatewayCredentialPath,
                 skillRuntime: channelContext.skillRuntime,
                 localhostGateway: channelContext.localhostGateway,
                 taskAssignmentContext: channelContext.payload.taskAssignmentContext,
-                taskWorkspace: channelContext.taskWorkspace,
+                resolvedWorkspace: channelContext.resolvedWorkspace,
             }
             : {}),
+        runtimeSurface,
         collaborationTurnExecutionId: input.collaboration?.turnExecutionId,
         collaborationTurnMode: input.collaboration?.turnMode,
         collaborationOutcome: input.collaborationOutcome ?? channelContext?.payload.collaborationOutcome,
         attentionSnapshot: input.attentionSnapshot ?? channelContext?.payload.attentionSnapshot,
+        compactionSnapshot: input.compactionSnapshot ?? channelContext?.payload.compactionSnapshot,
         ...(() => {
             const collaborationCapabilities = input.collaborationCapabilities ?? channelContext?.payload.collaborationCapabilities;
             return collaborationCapabilities ? { collaborationCapabilities } : {};
@@ -70,16 +82,30 @@ function resolveProviderSessionRouting(input) {
 export class ProviderTurnPreparer {
     channelContextStore;
     logger;
-    constructor(channelContextStore, logger = new HostLogger()) {
+    resolveProjectionStrategy;
+    constructor(channelContextStore, logger = new HostLogger(), options = {}) {
         this.channelContextStore = channelContextStore;
         this.logger = logger;
+        this.resolveProjectionStrategy = options.resolveProjectionStrategy
+            ?? (async () => options.projectionStrategy ?? DEFAULT_PROJECTION_STRATEGY);
     }
     async prepare(input) {
+        const incomingParts = input.incomingParts ?? buildHostedTurnContentParts({
+            text: input.incomingContent,
+        });
+        const incomingContent = incomingParts.length > 0
+            ? buildHostedIncomingContentText(incomingParts)
+            : input.incomingContent;
+        const projectionStrategy = input.provider === 'claude'
+            ? await this.resolveProjectionStrategy(input)
+            : undefined;
         let channelContext;
         if (this.channelContextStore) {
             try {
                 const prepareInput = {
                     channelId: input.channelId,
+                    provider: input.provider,
+                    projectionStrategy,
                     collaboration: input.collaboration
                         ? {
                             ...input.collaboration,
@@ -89,6 +115,7 @@ export class ProviderTurnPreparer {
                         : undefined,
                     collaborationOutcome: input.collaborationOutcome,
                     attentionSnapshot: input.attentionSnapshot,
+                    compactionSnapshot: input.compactionSnapshot,
                     collaborationCapabilities: input.collaborationCapabilities,
                     missedCollaborationDiagnostic: input.missedCollaborationDiagnostic,
                     ...(input.taskThreadCollaborationContract
@@ -97,8 +124,8 @@ export class ProviderTurnPreparer {
                     ...(input.incomingMessageType !== undefined
                         ? { incomingMessageType: input.incomingMessageType }
                         : {}),
-                    ...(input.incomingMessageType !== undefined && input.incomingContent !== undefined
-                        ? { incomingContent: input.incomingContent }
+                    ...(input.incomingMessageType !== undefined && incomingContent !== undefined
+                        ? { incomingContent }
                         : {}),
                 };
                 channelContext = await this.channelContextStore.prepare(prepareInput);
@@ -115,19 +142,43 @@ export class ProviderTurnPreparer {
         }
         const promptContext = toPromptContext(channelContext, input);
         return {
+            agentName: input.agentName,
             channelId: input.channelId,
+            incomingContent,
+            incomingParts,
             incomingEventKind: input.incomingEventKind,
             incomingMessageType: input.incomingMessageType,
-            prompt: buildPrompt({
-                agentName: input.agentName,
-                provider: input.provider,
-                channelId: input.channelId,
-                incomingAuthorId: input.incomingAuthorId,
-                incomingContent: input.incomingContent,
-                incomingEventKind: input.incomingEventKind,
-                incomingMessageType: input.incomingMessageType,
-                promptContext,
-            }),
+            prompt: input.provider === 'claude'
+                ? buildClaudeTurnPrompt({
+                    agentName: input.agentName,
+                    channelId: input.channelId,
+                    incomingAuthorId: input.incomingAuthorId,
+                    incomingContent,
+                    incomingEventKind: input.incomingEventKind,
+                    incomingMessageType: input.incomingMessageType,
+                    promptContext,
+                    promptStrategy: projectionStrategy,
+                })
+                : buildPrompt({
+                    agentName: input.agentName,
+                    provider: input.provider,
+                    channelId: input.channelId,
+                    incomingAuthorId: input.incomingAuthorId,
+                    incomingContent,
+                    incomingEventKind: input.incomingEventKind,
+                    incomingMessageType: input.incomingMessageType,
+                    promptContext,
+                }),
+            ...(input.provider === 'claude'
+                ? {
+                    claudeSessionPromptAppend: buildClaudeSessionPromptAppend({
+                        agentName: input.agentName,
+                        promptContext,
+                        promptStrategy: projectionStrategy,
+                    }),
+                    projectionStrategy,
+                }
+                : {}),
             promptContext,
             providerSessionRouting: resolveProviderSessionRouting(input),
         };

package/dist/gateway/localhost-gateway.js

@@ -655,8 +655,14 @@ class LoopbackLocalhostGatewayController {
         this.recordAudit('authorized', 200, decision.path, method ?? 'PUT', decision.binding);
     }
     async loadCurrentThreadTask(binding) {
+        // Only a task-thread binding has a current task at all. Without that context the scan below
+        // would list every visible channel's tasks to conclude what the binding already says, so the
+        // parent-channel answer is given here instead of after an O(channels x tasks) sweep.
+        if (binding.payload?.taskAssignmentContext?.active !== true) {
+            throw new GatewayHttpError(404, { error: 'not_found' }, 'not-found');
+        }
         let task;
-        const preferredTaskId = binding.payload?.taskAssignmentContext?.currentTaskId;
+        const preferredTaskId = binding.payload.taskAssignmentContext.currentTaskId;
         try {
             task = await findTaskForThread(this.controlPlane, binding.channelId, preferredTaskId);
         }
@@ -899,17 +905,21 @@ function mapGatewayControlPlaneError(error, fallbackReason) {
             case 'bpp.channel_id_required':
             case 'bpp.task_id_required':
                 return new GatewayHttpError(400, { error: 'bad_request' }, 'bad-request');
-            // An unregistered key or an oversized value is the caller's own mistake.
-            // Falling through to 502 would tell the agent the server is broken, and it
-            // would retry the same bad call instead of correcting it.
+            // An unregistered key, an oversized value or a status outside the enum is the
+            // caller's own mistake. Falling through to 502 would tell the agent the server
+            // is broken, and it would retry the same bad call instead of correcting it.
             case 'bpp.task_property_key_unknown':
                 return new GatewayHttpError(400, { error: 'unknown_property_key' }, 'bad-request');
+            case 'bpp.task_property_value_invalid':
+                return new GatewayHttpError(400, { error: 'invalid_property_value' }, 'bad-request');
             case 'bpp.task_property_value_too_long':
                 return new GatewayHttpError(400, { error: 'property_value_too_long' }, 'bad-request');
-            // A distinct body, not the bare `not_found` the other routes use: the CLI
-            // reads that one on a current-task request as "the thread's task could not
-            // be resolved" and tells the agent to pass --task-id, which is the wrong
-            // correction for a key that simply was not set.
+            case 'bpp.task_invalid_status':
+                return new GatewayHttpError(400, { error: 'invalid_status' }, 'bad-request');
+            // A distinct body, not the bare `not_found` the other routes use: on a
+            // current-task property request `not_found` means the thread's own task
+            // could not be resolved, and "pass the task id" is the wrong correction
+            // for a key that simply was not set.
             case 'bpp.task_property_not_found':
                 return new GatewayHttpError(404, { error: 'property_not_found' }, 'not-found');
             default:

package/dist/hosted-turn-content.d.ts

@@ -0,0 +1,15 @@
+import type { HostedMessageAttachment, HostedTurnContentPart } from './types.js';
+type CanonicalHostedMessageAttachment = HostedMessageAttachment & {
+    kind: NonNullable<HostedMessageAttachment['kind']>;
+};
+export declare function normalizeHostedMessageAttachment(attachment: HostedMessageAttachment): CanonicalHostedMessageAttachment;
+export declare function classifyHostedAttachmentKind(contentType: string | undefined): Extract<HostedTurnContentPart, {
+    type: 'image' | 'file';
+}>['type'];
+export declare function buildHostedTurnContentParts(input: {
+    text?: string;
+    attachments?: readonly HostedMessageAttachment[];
+}): HostedTurnContentPart[];
+export declare function extractHostedMessageAttachments(parts: readonly HostedTurnContentPart[]): HostedMessageAttachment[];
+export declare function buildHostedIncomingContentText(parts: readonly HostedTurnContentPart[]): string;
+export {};

package/dist/hosted-turn-content.js

@@ -0,0 +1,50 @@
+export function normalizeHostedMessageAttachment(attachment) {
+    return {
+        url: attachment.url,
+        ...(attachment.filename ? { filename: attachment.filename } : {}),
+        contentType: attachment.contentType,
+        kind: attachment.kind ?? classifyHostedAttachmentKind(attachment.contentType),
+        ...(attachment.sizeBytes !== undefined ? { sizeBytes: attachment.sizeBytes } : {}),
+    };
+}
+export function classifyHostedAttachmentKind(contentType) {
+    return contentType?.toLowerCase().startsWith('image/') ? 'image' : 'file';
+}
+export function buildHostedTurnContentParts(input) {
+    const text = input.text?.trim() ?? '';
+    const attachments = input.attachments ?? [];
+    const parts = [];
+    if (text.length > 0) {
+        parts.push({ type: 'text', text });
+    }
+    for (const attachment of attachments) {
+        const normalizedAttachment = normalizeHostedMessageAttachment(attachment);
+        parts.push({
+            type: normalizedAttachment.kind,
+            attachment: normalizedAttachment,
+        });
+    }
+    return parts;
+}
+export function extractHostedMessageAttachments(parts) {
+    return parts.flatMap((part) => ('attachment' in part ? [normalizeHostedMessageAttachment(part.attachment)] : []));
+}
+export function buildHostedIncomingContentText(parts) {
+    const text = parts
+        .flatMap((part) => (part.type === 'text' ? [part.text] : []))
+        .join('\n')
+        .trim();
+    const nonTextParts = parts.filter((part) => part.type === 'image' || part.type === 'file');
+    if (nonTextParts.length === 0) {
+        return text;
+    }
+    const summaryLines = [
+        `[Attachment metadata was received for ${nonTextParts.length} attachment${nonTextParts.length === 1 ? '' : 's'}]`,
+        ...nonTextParts.map((part, index) => {
+            const filename = part.attachment.filename?.trim();
+            return `${index + 1}. ${part.type};${filename ? ` filename: ${filename};` : ''} content type: ${part.attachment.contentType}`;
+        }),
+    ];
+    const summary = summaryLines.join('\n');
+    return text ? `${text}\n\n${summary}` : summary;
+}

package/dist/managed-daemon.d.ts

@@ -95,6 +95,7 @@ export interface ManagedAgentsHostDaemonDeps {
     materialize?: (rootPath: string, spec: LocalConfigGenerateSpec) => Promise<unknown>;
     logger?: Pick<Console, 'log' | 'error'>;
     logPath?: string;
+    platform?: NodeJS.Platform;
 }
 export interface DescribeManagedSpecOptions {
     serverUrl: string;
@@ -192,7 +193,7 @@ export declare function applyManagedSpec(options: ApplyManagedSpecOptions, deps?
 export declare class ManagedAgentsHostDaemon {
     private readonly rootPath;
     private readonly hostConfigPath;
-    private readonly socketPath;
+    private readonly endpoint;
     private readonly createSupervisor;
     private readonly supervisor;
     private readonly loadSpec;
@@ -204,7 +205,7 @@ export declare class ManagedAgentsHostDaemon {
     private requestQueue;
     private started;
     private ready;
-    private ownsSocket;
+    private ownsEndpoint;
     private shutdownRequested;
     private ownedSocketInode;
     constructor(rootPath: string, debug?: boolean, deps?: ManagedAgentsHostDaemonDeps);