@borgee/agents-host 0.2.44 → 0.2.56

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,7 +1,8 @@
 import { HostLogger, summarizeError } from '../debug.js';
+import { DEFAULT_PROJECTION_STRATEGY } from '../projection-strategy-values.js';
 import { buildHostedIncomingContentText, buildHostedTurnContentParts } from '../hosted-turn-content.js';
-import { ChannelContextPreparationError, } from './injection.js';
-import { buildPrompt } from './prompt.js';
+import { buildRuntimeSurfaceForTurn, ChannelContextPreparationError, } from './injection.js';
+import { buildClaudeSessionPromptAppend, buildClaudeTurnPrompt, buildPrompt } from './prompt.js';
 function providerLabel(provider) {
     if (provider === 'copilot') {
         return 'Copilot';
@@ -16,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,
+                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 } : {};
@@ -71,9 +82,12 @@ 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({
@@ -82,11 +96,16 @@ export class ProviderTurnPreparer {
         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,
@@ -96,6 +115,7 @@ export class ProviderTurnPreparer {
                         : undefined,
                     collaborationOutcome: input.collaborationOutcome,
                     attentionSnapshot: input.attentionSnapshot,
+                    compactionSnapshot: input.compactionSnapshot,
                     collaborationCapabilities: input.collaborationCapabilities,
                     missedCollaborationDiagnostic: input.missedCollaborationDiagnostic,
                     ...(input.taskThreadCollaborationContract
@@ -122,21 +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,
-                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

@@ -910,6 +910,8 @@ function mapGatewayControlPlaneError(error, fallbackReason) {
             // 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');
             case 'bpp.task_invalid_status':

package/dist/managed-daemon.js

@@ -2,13 +2,15 @@ import { createHash, randomUUID } from 'node:crypto';
 import { promises as fs } from 'node:fs';
 import { spawn } from 'node:child_process';
 import { createConnection, createServer } from 'node:net';
-import { dirname, join, resolve } from 'node:path';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { AgentsHostSupervisor } from './agents-host-supervisor.js';
-import { CLAUDE_PROVIDER_V2_COMPATIBILITY_GATE, COMPATIBILITY_GATES_ENV, createManagedRuntimeSettingsFingerprint, INTERNAL_DISABLED_COMPATIBILITY_GATES_ENV, INTERNAL_POLICY_MODE_ENV, INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV, MANAGED_RUNTIME_CONVERGENCE_COMPATIBILITY_GATE, MANAGED_RUNTIME_SETTINGS_SCHEMA_VERSION, resolveDisabledDefaultCompatibilityGates, resolveManagedRuntimeSettingsSnapshot, normalizeInternalProviderImplementationOverrides, } from './compatibility-gates.js';
+import { DEFAULT_PROJECTION_STRATEGY, normalizeProjectionStrategy, } from './projection-strategy-values.js';
+import { resolveChannelWorkspaceDirectory, resolveChannelWorkspaceRootDirectory, resolveManagedWorkspaceCollectionRoot, resolveTaskWorkspaceDirectory, } from './context/injection.js';
+import { CLAUDE_PROVIDER_V2_COMPATIBILITY_GATE, COMPATIBILITY_GATES_ENV, createManagedRuntimeSettingsFingerprint, INTERNAL_CLAUDE_PROMPT_STRATEGY_ENV, INTERNAL_DISABLED_COMPATIBILITY_GATES_ENV, INTERNAL_POLICY_MODE_ENV, INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV, MANAGED_RUNTIME_CONVERGENCE_COMPATIBILITY_GATE, MANAGED_RUNTIME_SETTINGS_SCHEMA_VERSION, resolveDisabledDefaultCompatibilityGates, resolveManagedRuntimeSettingsSnapshot, serializeManagedRuntimeSettingsSnapshot, normalizeInternalProviderImplementationOverrides, } from './compatibility-gates.js';
 import { DEFAULT_PROVIDER_COMMAND_CONFIG, hasLegacyClaudeOneShotArgs, loadConfigFromEnv, } from './config.js';
 import { loadLocalConfigGenerateSpec, materializeLocalConfig, parseGenerateConfigSpec, resolveLocalConfigLayout, } from './local-config.js';
-import { normalizeManagedRuntimeKey, resolveManagedBootstrapLockPath, resolveManagedDaemonEndpoint, resolveManagedDaemonLogPath, resolveManagedRuntimeRoot, resolveManagedRuntimeSettingsPath, } from './state-paths.js';
+import { normalizeManagedRuntimeKey, resolveManagedBootstrapLockPath, resolveManagedDaemonEndpoint, resolveManagedDaemonLogPath, resolveManagedRuntimeRoot, resolveManagedStateRoot, resolveManagedRuntimeSettingsPath, } from './state-paths.js';
 const MANAGED_ROOT_MODE = 0o700;
 const MANAGED_CONFIG_MODE = 0o600;
 const BOOTSTRAP_LOCK_WAIT_MS = 10_000;
@@ -48,6 +50,9 @@ function isAlreadyExistsError(error) {
 function isSocketBusyError(error) {
     return isNodeErrorWithCode(error, 'EADDRINUSE');
 }
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
 function delay(milliseconds) {
     return new Promise((resolveDelay) => {
         setTimeout(resolveDelay, milliseconds);
@@ -157,6 +162,7 @@ function normalizeManagedRuntimeSettingsSnapshot(snapshot) {
         compatibilityGates,
         providerImplementationOverrides,
         internalPolicyMode: snapshot.internalPolicyMode,
+        projectionStrategy: snapshot.projectionStrategy ?? DEFAULT_PROJECTION_STRATEGY,
     };
 }
 function parseManagedRuntimeSettingsSnapshotRecord(value, sourceLabel) {
@@ -178,11 +184,19 @@ function parseManagedRuntimeSettingsSnapshotRecord(value, sourceLabel) {
     if (record.internalPolicyMode !== 'audit-only' && record.internalPolicyMode !== 'enforce') {
         throw new Error(`Invalid ${sourceLabel}: expected internalPolicyMode to be "audit-only" or "enforce"`);
     }
+    const rawProjectionStrategy = typeof record.projectionStrategy === 'string'
+        ? record.projectionStrategy
+        : record.claudePromptStrategy;
+    const projectionStrategy = normalizeProjectionStrategy(rawProjectionStrategy);
+    if (rawProjectionStrategy !== undefined && !projectionStrategy) {
+        throw new Error(`Invalid ${sourceLabel}: expected projectionStrategy to be "session-brief", "turn-full", "message-only", "turn-thin", or "file-brief"`);
+    }
     return normalizeManagedRuntimeSettingsSnapshot({
         schemaVersion: MANAGED_RUNTIME_SETTINGS_SCHEMA_VERSION,
         compatibilityGates: [...record.compatibilityGates],
         providerImplementationOverrides: [...record.providerImplementationOverrides],
         internalPolicyMode: record.internalPolicyMode,
+        projectionStrategy: projectionStrategy ?? DEFAULT_PROJECTION_STRATEGY,
     });
 }
 async function loadManagedRuntimeSettingsSnapshot(rootPath) {
@@ -205,7 +219,7 @@ async function writeManagedRuntimeSettingsSnapshot(rootPath, snapshot) {
     await ensureDirectory(rootPath, MANAGED_ROOT_MODE);
     const settingsPath = resolveManagedRuntimeSettingsPath(rootPath);
     const normalizedSnapshot = normalizeManagedRuntimeSettingsSnapshot(snapshot);
-    await fs.writeFile(settingsPath, `${JSON.stringify(normalizedSnapshot)}\n`, {
+    await fs.writeFile(settingsPath, `${serializeManagedRuntimeSettingsSnapshot(normalizedSnapshot)}\n`, {
         encoding: 'utf8',
         mode: MANAGED_CONFIG_MODE,
     });
@@ -226,6 +240,7 @@ function buildManagedRuntimeSettingsEnv(baseEnv, snapshot) {
         [INTERNAL_DISABLED_COMPATIBILITY_GATES_ENV]: resolveDisabledDefaultCompatibilityGates(snapshot.compatibilityGates).join(','),
         [INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV]: snapshot.providerImplementationOverrides.join(','),
         [INTERNAL_POLICY_MODE_ENV]: snapshot.internalPolicyMode,
+        [INTERNAL_CLAUDE_PROMPT_STRATEGY_ENV]: snapshot.projectionStrategy,
     };
 }
 function buildDesiredManagedRuntimeSettingsFromSnapshot(snapshot) {
@@ -819,6 +834,101 @@ async function shutdownManagedDaemon(rootPath, sendRequest, waitForShutdown) {
     }
     await waitForShutdown(rootPath);
 }
+function resolveTrustedPersistedChannelWorkspaceRoot(workspaceCollectionRoot, owningChannelId, rootPath) {
+    if (!owningChannelId || !isAbsolute(rootPath)) {
+        return null;
+    }
+    const expectedWorkspacePath = resolveChannelWorkspaceDirectory(workspaceCollectionRoot, owningChannelId);
+    if (rootPath !== expectedWorkspacePath) {
+        return null;
+    }
+    return resolveChannelWorkspaceRootDirectory(workspaceCollectionRoot, owningChannelId);
+}
+async function discoverManagedWorkspaceRootsForPurge(rootPath, processEnv) {
+    const trustedWorkspaceCollectionRoots = new Set([
+        resolveManagedWorkspaceCollectionRoot(undefined, processEnv),
+    ]);
+    const managedStateRoot = resolveManagedStateRoot(rootPath);
+    const agentStateEntries = await fs.readdir(managedStateRoot, { withFileTypes: true }).catch((error) => {
+        if (isNotFoundError(error)) {
+            return [];
+        }
+        throw error;
+    });
+    const workspaceRoots = new Set();
+    for (const agentStateEntry of agentStateEntries) {
+        if (!agentStateEntry.isDirectory()) {
+            continue;
+        }
+        const channelContextRoot = join(managedStateRoot, agentStateEntry.name, 'channel-context');
+        const channelEntries = await fs.readdir(channelContextRoot, { withFileTypes: true }).catch((error) => {
+            if (isNotFoundError(error)) {
+                return [];
+            }
+            throw error;
+        });
+        for (const channelEntry of channelEntries) {
+            if (!channelEntry.isDirectory()) {
+                continue;
+            }
+            const payloadPath = join(channelContextRoot, channelEntry.name, 'context.json');
+            const payload = await fs.readFile(payloadPath, 'utf8').catch((error) => {
+                if (isNotFoundError(error)) {
+                    return undefined;
+                }
+                throw error;
+            });
+            if (!payload) {
+                continue;
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(payload);
+            }
+            catch {
+                continue;
+            }
+            if (!isRecord(parsed) || typeof parsed.channelId !== 'string' || !isRecord(parsed.resolvedWorkspace)) {
+                continue;
+            }
+            const resolvedWorkspace = parsed.resolvedWorkspace;
+            if ((resolvedWorkspace.authority !== 'channel' && resolvedWorkspace.authority !== 'task')
+                || typeof resolvedWorkspace.rootPath !== 'string'
+                || !isAbsolute(resolvedWorkspace.rootPath)) {
+                continue;
+            }
+            for (const workspaceCollectionRoot of trustedWorkspaceCollectionRoots) {
+                if (resolvedWorkspace.authority === 'channel') {
+                    if (typeof resolvedWorkspace.owningChannelId !== 'string'
+                        || resolvedWorkspace.owningChannelId.length === 0) {
+                        continue;
+                    }
+                    const trustedChannelWorkspaceRoot = resolveTrustedPersistedChannelWorkspaceRoot(workspaceCollectionRoot, resolvedWorkspace.owningChannelId, resolvedWorkspace.rootPath);
+                    if (!trustedChannelWorkspaceRoot) {
+                        continue;
+                    }
+                    workspaceRoots.add(trustedChannelWorkspaceRoot);
+                    break;
+                }
+                const expectedWorkspacePath = resolvedWorkspace.authority === 'task'
+                    ? typeof resolvedWorkspace.taskId === 'string' && resolvedWorkspace.taskId.length > 0
+                        ? resolveTaskWorkspaceDirectory(workspaceCollectionRoot, parsed.channelId, resolvedWorkspace.taskId)
+                        : null
+                    : null;
+                if (!expectedWorkspacePath) {
+                    continue;
+                }
+                if (resolvedWorkspace.rootPath !== expectedWorkspacePath) {
+                    continue;
+                }
+                workspaceRoots.add(dirname(expectedWorkspacePath));
+                workspaceRoots.add(resolveChannelWorkspaceRootDirectory(workspaceCollectionRoot, parsed.channelId));
+                break;
+            }
+        }
+    }
+    return [...workspaceRoots].sort((left, right) => left.localeCompare(right));
+}
 export async function cleanupManagedRuntime(options, deps = {}) {
     const sendRequest = deps.sendRequest ?? sendManagedDaemonRequest;
     const removeRuntimeRoot = deps.removeRuntimeRoot ??
@@ -855,6 +965,9 @@ export async function cleanupManagedRuntime(options, deps = {}) {
         await waitForShutdown(resolved.rootPath);
     }
     if (options.purge === true) {
+        for (const workspaceRoot of await discoverManagedWorkspaceRootsForPurge(resolved.rootPath, options.processEnv ?? process.env)) {
+            await fs.rm(workspaceRoot, { recursive: true, force: true });
+        }
         await removeRuntimeRoot(resolved.rootPath);
     }
 }
@@ -900,16 +1013,16 @@ export async function spawnManagedDaemonProcess(options, deps = {}) {
     }
     const thisPath = fileURLToPath(import.meta.url);
     const cliEntrypointPath = join(dirname(thisPath), thisPath.endsWith('.ts') ? 'cli.ts' : 'cli.js');
+    const baseEnv = {
+        ...process.env,
+        ...(options.processEnv ?? {}),
+    };
     return spawnDetachedProcess({
         rootPath: options.rootPath,
         command: process.execPath,
         env: {
-            ...buildManagedRuntimeSettingsEnv({
-                ...process.env,
-                ...(options.processEnv ?? {}),
-            }, managedRuntimeSettingsSnapshot),
+            ...buildManagedRuntimeSettingsEnv(baseEnv, managedRuntimeSettingsSnapshot),
             AGENTS_HOST_MANAGED_DAEMON_LOG_PATH: resolveManagedDaemonLogPath(options.rootPath),
-            AGENTS_HOST_INTERNAL_TASK_WORKSPACE_ROOT_DIR: options.rootPath,
         },
         args: [
             ...process.execArgv,