@borgee/agents-host 0.2.35 → 0.2.56

package/dist/providers/copilot/cli-client.js

@@ -2,6 +2,7 @@ import { Readable, Writable } from 'node:stream';
 import spawn from 'cross-spawn';
 import { PROTOCOL_VERSION, client, methods, ndJsonStream, } from '@agentclientprotocol/sdk';
 import { HostLogger, summarizeChildStderr, summarizeError } from '../../debug.js';
+import { AcpProgressCollector } from '../acp-progress-collector.js';
 import { resolveCopilotPermissionResponse } from '../../policy/copilot-permission.js';
 import { IDLE_BACKEND_SHUTDOWN_DISABLED_MS, IdleBackendShutdownScheduler, } from '../idle-backend-shutdown.js';
 const SESSION_TAINTED_ERRORS = new WeakSet();
@@ -30,93 +31,35 @@ const DEFAULT_RUNTIME = {
     idleShutdownGracePeriodMs: DEFAULT_IDLE_SHUTDOWN_GRACE_PERIOD_MS,
     shutdownGracePeriodMs: DEFAULT_SHUTDOWN_GRACE_PERIOD_MS,
     shutdownForceKillWaitMs: DEFAULT_SHUTDOWN_FORCE_KILL_WAIT_MS,
+    fetch: async (input, init) => fetch(input, init),
 };
 const DEFAULT_SESSION_CAPABILITIES = {
     loadSession: false,
     resumeSession: false,
 };
-function hasVisibleText(value) {
-    return typeof value === 'string' && value.trim().length > 0;
+function isAbsoluteHttpUrl(value) {
+    return value.startsWith('http://') || value.startsWith('https://');
 }
-function formatToolProgress(title, status) {
-    const normalizedTitle = hasVisibleText(title) ? title.trim() : null;
-    switch (status) {
-        case 'completed':
-            return normalizedTitle ? `Completed ${normalizedTitle}` : 'Completed tool call';
-        case 'failed':
-            return normalizedTitle ? `Failed ${normalizedTitle}` : 'Tool call failed';
-        case 'pending':
-        case 'in_progress':
-        case undefined:
-        case null:
-            return normalizedTitle ? `Running ${normalizedTitle}…` : 'Running tool…';
-        default:
-            return normalizedTitle ? `${status} ${normalizedTitle}` : status;
+function resolveHostedAttachmentUrl(rawUrl, borgeeBaseUrl) {
+    if (isAbsoluteHttpUrl(rawUrl)) {
+        return rawUrl;
     }
+    const base = borgeeBaseUrl.replace(/\/$/, '');
+    const path = rawUrl.startsWith('/') ? rawUrl : `/${rawUrl}`;
+    return `${base}${path}`;
 }
-function formatPlanProgress(entries) {
-    const current = entries.find((entry) => entry.status === 'in_progress') ??
-        entries.find((entry) => entry.status === 'pending') ??
-        entries[0];
-    return hasVisibleText(current?.content) ? `Plan: ${current.content.trim()}` : null;
-}
-class CopilotProgressCollector {
-    onProgress;
-    publicText = '';
-    lastPublished = null;
-    toolTitles = new Map();
-    constructor(onProgress) {
-        this.onProgress = onProgress;
-    }
-    consume(update) {
-        switch (update.update.sessionUpdate) {
-            case 'agent_message_chunk':
-                if (update.update.content.type !== 'text') {
-                    return;
-                }
-                this.publicText += update.update.content.text;
-                this.publish(this.publicText);
-                return;
-            case 'tool_call':
-                this.toolTitles.set(update.update.toolCallId, update.update.title);
-                this.publishFallback(formatToolProgress(update.update.title, update.update.status));
-                return;
-            case 'tool_call_update': {
-                const nextTitle = update.update.title ?? this.toolTitles.get(update.update.toolCallId);
-                if (hasVisibleText(nextTitle)) {
-                    this.toolTitles.set(update.update.toolCallId, nextTitle);
-                }
-                this.publishFallback(formatToolProgress(nextTitle, update.update.status));
-                return;
-            }
-            case 'plan':
-                this.publishFallback(formatPlanProgress(update.update.entries.map((entry) => ({
-                    content: entry.content,
-                    status: entry.status,
-                }))));
-                return;
-            default:
-                return;
-        }
+function isSameOrigin(left, right) {
+    try {
+        return new URL(left).origin === new URL(right).origin;
     }
-    getFinalText() {
-        return this.publicText.trim();
-    }
-    publishFallback(text) {
-        if (hasVisibleText(this.publicText)) {
-            return;
-        }
-        this.publish(text);
-    }
-    publish(text) {
-        if (!this.onProgress || !hasVisibleText(text) || text === this.lastPublished) {
-            return;
-        }
-        this.lastPublished = text;
-        this.onProgress({ text });
+    catch {
+        return false;
     }
 }
-function createDeferredTurn(channelId, prompt, sessionPersistence, promptContext, options) {
+function asImagePart(part) {
+    return part.type === 'image' ? part : null;
+}
+function createDeferredTurn(channelId, preparedTurn, sessionPersistence, options) {
     let settled = false;
     let resolvePromise;
     let rejectPromise;
@@ -126,9 +69,8 @@ function createDeferredTurn(channelId, prompt, sessionPersistence, promptContext
     });
     return {
         channelId,
-        prompt,
+        preparedTurn,
         sessionPersistence,
-        promptContext,
         options,
         promise,
         resolve(value) {
@@ -216,6 +158,7 @@ export class CopilotCliClient {
     resolveSessionStoreAgentId;
     logger;
     permissionPolicy;
+    imageInputConfig;
     runtime;
     channels = new Map();
     /**
@@ -253,12 +196,13 @@ export class CopilotCliClient {
     sessionStoreWriteQueue = Promise.resolve();
     sessionCapabilities = DEFAULT_SESSION_CAPABILITIES;
     idleBackendShutdown;
-    constructor(command, _ignoredArgs = [], runtimeOverrides = {}, sessionStore, resolveSessionStoreAgentId = () => undefined, logger = new HostLogger(), permissionPolicy = {}) {
+    constructor(command, _ignoredArgs = [], runtimeOverrides = {}, sessionStore, resolveSessionStoreAgentId = () => undefined, logger = new HostLogger(), permissionPolicy = {}, imageInputConfig = {}) {
         this.command = command;
         this.sessionStore = sessionStore;
         this.resolveSessionStoreAgentId = resolveSessionStoreAgentId;
         this.logger = logger;
         this.permissionPolicy = permissionPolicy;
+        this.imageInputConfig = imageInputConfig;
         this.runtime = { ...DEFAULT_RUNTIME, ...runtimeOverrides };
         this.idleBackendShutdown = new IdleBackendShutdownScheduler({
             idleShutdownMs: this.runtime.idleBackendShutdownMs,
@@ -279,12 +223,19 @@ export class CopilotCliClient {
         if (this.fatalError) {
             throw this.fatalError;
         }
-        const preparedTurn = typeof channelIdOrTurn === 'string'
+        const preparedTurnBase = typeof channelIdOrTurn === 'string'
             ? {
                 channelId: channelIdOrTurn,
+                incomingContent: '',
+                incomingParts: [],
                 prompt: typeof promptOrOptions === 'string' ? promptOrOptions : '',
             }
             : channelIdOrTurn;
+        const preparedTurn = {
+            ...preparedTurnBase,
+            incomingContent: preparedTurnBase.incomingContent ?? '',
+            incomingParts: preparedTurnBase.incomingParts ?? [],
+        };
         const options = typeof channelIdOrTurn === 'string'
             ? maybeOptions
             : promptOrOptions;
@@ -292,7 +243,7 @@ export class CopilotCliClient {
         const state = this.getOrCreateChannelState(sessionRouting.key, preparedTurn.channelId, sessionRouting.persistence);
         this.clearIdleTimer(state);
         this.idleBackendShutdown.cancel();
-        const turn = createDeferredTurn(preparedTurn.channelId, preparedTurn.prompt, sessionRouting.persistence, preparedTurn.promptContext, options);
+        const turn = createDeferredTurn(preparedTurn.channelId, preparedTurn, sessionRouting.persistence, options);
         state.queue.push(turn);
         this.processChannelQueue(sessionRouting.key, state);
         return turn.promise;
@@ -455,13 +406,14 @@ export class CopilotCliClient {
                     }
                     state.activeTurn = turn;
                     try {
-                        state.cwd = await this.resolveSessionCwd(turn.promptContext);
+                        state.cwd = await this.resolveSessionCwd(turn.preparedTurn.promptContext);
                         await this.ensureStarted();
                         await this.recycleSessionIfCwdChanged(channelId, state);
                         const session = await this.getOrCreateSession(channelId, state);
                         let reply;
                         try {
-                            reply = await this.runTurn(session, turn.prompt, turn.options);
+                            const promptInput = await this.buildPromptInput(turn.preparedTurn);
+                            reply = await this.runTurn(session, promptInput, turn.options);
                         }
                         catch (error) {
                             if (isSessionTainted(error)) {
@@ -615,7 +567,38 @@ export class CopilotCliClient {
         }
     }
     async resolveSessionCwd(promptContext) {
-        return promptContext?.taskWorkspace?.rootPath ?? this.runtime.cwd;
+        return promptContext?.resolvedWorkspace?.rootPath ?? this.runtime.cwd;
+    }
+    async buildPromptInput(turn) {
+        const imageParts = turn.incomingParts.map(asImagePart).filter((part) => part !== null);
+        if (imageParts.length === 0) {
+            return turn.prompt;
+        }
+        const imageBlocks = await Promise.all(imageParts.map(async (part) => this.fetchImageBlock(part.attachment.url, part.attachment.contentType)));
+        return [{ type: 'text', text: turn.prompt }, ...imageBlocks];
+    }
+    async fetchImageBlock(rawUrl, contentType) {
+        const baseUrl = this.imageInputConfig.borgeeBaseUrl?.trim();
+        const agentApiKey = this.imageInputConfig.agentApiKey?.trim();
+        if (!baseUrl || !agentApiKey) {
+            throw new Error('Copilot image input requires Borgee base URL and agent API key');
+        }
+        const resolvedUrl = resolveHostedAttachmentUrl(rawUrl, baseUrl);
+        if (!isSameOrigin(resolvedUrl, baseUrl)) {
+            throw new Error(`Copilot image input only supports Borgee-origin attachments: ${resolvedUrl}`);
+        }
+        const response = await this.runtime.fetch(resolvedUrl, {
+            headers: { Authorization: `Bearer ${agentApiKey}` },
+        });
+        if (!response.ok) {
+            throw new Error(`Copilot image fetch failed with ${response.status} ${response.statusText}`.trim());
+        }
+        return {
+            type: 'image',
+            mimeType: contentType,
+            data: Buffer.from(await response.arrayBuffer()).toString('base64'),
+            uri: response.url || resolvedUrl,
+        };
     }
     async recycleSessionIfCwdChanged(channelId, state) {
         const session = state.session;
@@ -644,7 +627,7 @@ export class CopilotCliClient {
         const promptFailure = new Promise((_, reject) => {
             void promptPromise.catch((error) => reject(markSessionTainted(error)));
         });
-        const collector = new CopilotProgressCollector(options?.onProgress);
+        const collector = new AcpProgressCollector(options?.onProgress);
         for (;;) {
             let update;
             try {

package/dist/providers/create-provider.d.ts

@@ -1,12 +1,14 @@
 import type { DebugLogger } from '../debug.js';
 import type { ProviderRuntimeConfig } from '../types.js';
-import type { ProviderAdapter } from './provider-adapter.js';
+import type { ChatControlPlane } from '../chat/chat-control-plane.js';
+import { type ProviderAdapter } from './provider-adapter.js';
 import type { LocalhostGatewayContextPublisher } from '../context/injection.js';
 import type { AuthorizationAuditSinkLike } from '../policy/authorization-audit.js';
 interface CreateProviderOptions {
     compatibilityGates?: ReadonlySet<string>;
     localhostGateway?: LocalhostGatewayContextPublisher;
     authorizationAuditSink?: AuthorizationAuditSinkLike;
+    controlPlane?: Pick<ChatControlPlane, 'getTask' | 'listChannels' | 'listTasks'>;
 }
 export declare function createProvider(config: ProviderRuntimeConfig, debugLogger?: DebugLogger, options?: CreateProviderOptions): ProviderAdapter;
 export {};

package/dist/providers/create-provider.js

@@ -1,7 +1,8 @@
 import { FileChannelContextStore } from '../context/injection.js';
+import { ServerProjectionStrategyResolver } from '../context/projection-strategy.js';
 import { createProviderConnectionsSessionStore } from '../connections-state-store.js';
 import { ProviderTurnPreparer } from '../context/turn-preparation.js';
-import { CONNECTIONS_STATE_LAYER_COMPATIBILITY_GATE, CONTEXT_INJECTION_COMPATIBILITY_GATE, CODEX_PROVIDER_COMPATIBILITY_GATE, COPILOT_PROVIDER_V2_COMPATIBILITY_GATE, INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV, LOCALHOST_GATEWAY_COMPATIBILITY_GATE, parseInternalProviderImplementationOverrides, POLICY_AUDIT_ENFORCEMENT_COMPATIBILITY_GATE, resolveInternalPolicyMode, resolveInternalCompatibilityGates, SKILL_RUNTIME_COMPATIBILITY_GATE, } from '../compatibility-gates.js';
+import { CONNECTIONS_STATE_LAYER_COMPATIBILITY_GATE, CONTEXT_INJECTION_COMPATIBILITY_GATE, CODEX_PROVIDER_COMPATIBILITY_GATE, COPILOT_PROVIDER_V2_COMPATIBILITY_GATE, INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV, LOCALHOST_GATEWAY_COMPATIBILITY_GATE, parseInternalProviderImplementationOverrides, POLICY_AUDIT_ENFORCEMENT_COMPATIBILITY_GATE, resolveInternalPolicyMode, resolveInternalCompatibilityGates, resolveInternalProjectionStrategy, SKILL_RUNTIME_COMPATIBILITY_GATE, } from '../compatibility-gates.js';
 import { resolveIdleBackendShutdownMs } from './idle-backend-shutdown.js';
 import { ClaudeCliClient } from './claude/cli-client.js';
 import { ClaudeProviderAdapter } from './claude/adapter.js';
@@ -10,16 +11,18 @@ import { CodexCliClient } from './codex/cli-client.js';
 import { CodexProviderAdapter } from './codex/adapter.js';
 import { FileCodexChannelSessionStore } from './codex/session-store.js';
 import { CopilotCliClient } from './copilot/cli-client.js';
-import { CopilotProviderAdapter } from './copilot/adapter.js';
+import { COPILOT_HOSTED_PROVIDER_CAPABILITIES, CopilotProviderAdapter } from './copilot/adapter.js';
 import { FileCopilotChannelSessionStore } from './copilot/session-store.js';
 import { resolveClaudeSessionMapPath, resolveCodexSessionMapPath, resolveCopilotSessionMapPath, } from '../state-paths.js';
 import { createAwaitingUserProgressHandler, parseProviderReply } from './awaiting-user.js';
 class ProviderV2CompatibilityAdapter {
     provider;
     turnPreparer;
-    constructor(provider, turnPreparer) {
+    capabilities;
+    constructor(provider, turnPreparer, capabilities) {
         this.provider = provider;
         this.turnPreparer = turnPreparer;
+        this.capabilities = capabilities;
     }
     async generateReply(input, options) {
         const preparedTurn = await this.turnPreparer.prepare(input);
@@ -50,7 +53,6 @@ class CliBackedProviderV2 {
 }
 class CopilotProviderV2 extends CliBackedProviderV2 {
 }
-const TASK_WORKSPACE_ROOT_DIR_ENV = 'AGENTS_HOST_INTERNAL_TASK_WORKSPACE_ROOT_DIR';
 const PROVIDER_V2_COMPATIBILITY_GATES = {
     copilot: COPILOT_PROVIDER_V2_COMPATIBILITY_GATE,
 };
@@ -69,7 +71,10 @@ function createClaudeProvider(config, debugLogger, connectionsStateGateEnabled,
         stateRootDir: config.stateRootDir,
         gateEnabled: connectionsStateGateEnabled,
         logger: debugLogger,
-    }), config.resolveStableAgentId, debugLogger);
+    }), config.resolveStableAgentId, debugLogger, {
+        borgeeBaseUrl: config.borgeeBaseUrl,
+        agentApiKey: config.agentApiKey,
+    });
     return new ClaudeProviderAdapter(cli, turnPreparer);
 }
 function createCopilotProvider(config, debugLogger, connectionsStateGateEnabled, implementation, turnPreparer, policyAuditGateEnabled, authorizationAuditSink, idleBackendShutdownMs) {
@@ -89,9 +94,12 @@ function createCopilotProvider(config, debugLogger, connectionsStateGateEnabled,
         gateEnabled: policyAuditGateEnabled,
         policyMode,
         auditSink: authorizationAuditSink,
+    }, {
+        borgeeBaseUrl: config.borgeeBaseUrl,
+        agentApiKey: config.agentApiKey,
     });
     return implementation === 'v2'
-        ? new ProviderV2CompatibilityAdapter(new CopilotProviderV2(cli), turnPreparer)
+        ? new ProviderV2CompatibilityAdapter(new CopilotProviderV2(cli), turnPreparer, COPILOT_HOSTED_PROVIDER_CAPABILITIES)
         : new CopilotProviderAdapter(cli, turnPreparer);
 }
 function createCodexProvider(config, debugLogger, connectionsStateGateEnabled, turnPreparer, idleBackendShutdownMs) {
@@ -103,7 +111,10 @@ function createCodexProvider(config, debugLogger, connectionsStateGateEnabled, t
         stateRootDir: config.stateRootDir,
         gateEnabled: connectionsStateGateEnabled,
         logger: debugLogger,
-    }), config.resolveStableAgentId, debugLogger);
+    }), config.resolveStableAgentId, debugLogger, {
+        borgeeBaseUrl: config.borgeeBaseUrl,
+        agentApiKey: config.agentApiKey,
+    });
     return new CodexProviderAdapter(cli, turnPreparer);
 }
 export function createProvider(config, debugLogger, options = {}) {
@@ -120,13 +131,29 @@ export function createProvider(config, debugLogger, options = {}) {
     const channelContextStore = contextInjectionGateEnabled
         ? new FileChannelContextStore(config.stateRootDir, {
             skillRuntimeEnabled: skillRuntimeGateEnabled,
-            taskWorkspaceRootDir: process.env[TASK_WORKSPACE_ROOT_DIR_ENV],
             localhostGateway: skillRuntimeGateEnabled && localhostGatewayGateEnabled
                 ? options.localhostGateway
                 : undefined,
+            taskReader: options.controlPlane,
         })
         : undefined;
-    const turnPreparer = new ProviderTurnPreparer(channelContextStore, debugLogger);
+    const resolveInternalProjection = () => resolveInternalProjectionStrategy();
+    const projectionStrategyResolver = new ServerProjectionStrategyResolver({
+        baseUrl: config.borgeeBaseUrl,
+        agentApiKey: config.agentApiKey,
+        resolveStableAgentId: config.resolveStableAgentId,
+        fallback: resolveInternalProjection,
+        logger: debugLogger,
+        taskReader: options.controlPlane,
+    });
+    const turnPreparer = new ProviderTurnPreparer(channelContextStore, debugLogger, {
+        resolveProjectionStrategy: async (input) => {
+            if (input.provider !== 'claude') {
+                return resolveInternalProjection();
+            }
+            return projectionStrategyResolver.resolve(input.channelId);
+        },
+    });
     switch (config.provider) {
         case 'claude': {
             return createClaudeProvider(config, debugLogger, connectionsStateGateEnabled, turnPreparer, idleBackendShutdownMs);

package/dist/providers/provider-adapter.d.ts

@@ -1,5 +1,40 @@
 import type { ProviderGenerateOptions, ProviderInput, ProviderReply } from '../types.js';
+export type ProviderImageInputSupport = 'supported' | 'metadata-only' | 'not-supported';
+export type ProviderImageTransportSupport = 'supported' | 'not-supported';
+export type ProviderImageTransportSource = 'transport-derived' | 'runtime-derived';
+export type ProviderImageTransportDelivery = 'host-materialized-local-path' | 'blob';
+export type ProviderImageInputReason = 'real-media-delivered' | 'shared-host-attachment-metadata-fallback' | 'host-policy-blocked';
+export type ProviderImageTransportReason = 'real-media-delivered' | 'transport-does-not-deliver-real-media' | 'runtime-capability-not-yet-resolved' | 'host-policy-blocked';
+export interface SharedHostAttachmentMetadataFallbackCapability {
+    support: 'metadata-only';
+    delivery: 'prompt-text-attachment-metadata';
+}
+export interface ProviderImageTransportCapability {
+    source: ProviderImageTransportSource;
+    support: ProviderImageTransportSupport;
+    reason: ProviderImageTransportReason;
+    delivery: readonly ProviderImageTransportDelivery[];
+    maxImageCount?: number;
+    maxBytesPerImage?: number;
+    maxTotalBytes?: number;
+}
+export interface ProviderImageCapability {
+    support: ProviderImageInputSupport;
+    reason: ProviderImageInputReason;
+    sharedHostFallback: SharedHostAttachmentMetadataFallbackCapability;
+    transport: ProviderImageTransportCapability;
+}
+export interface ProviderCapabilities {
+    imageInput: ProviderImageCapability;
+}
+export declare const SHARED_HOST_ATTACHMENT_METADATA_FALLBACK: SharedHostAttachmentMetadataFallbackCapability;
+export declare function createHostedProviderCapabilities(params: {
+    imageInputTransport: ProviderImageTransportCapability;
+    sharedHostFallback?: SharedHostAttachmentMetadataFallbackCapability;
+}): ProviderCapabilities;
+export declare const TEXT_ONLY_HOSTED_PROVIDER_CAPABILITIES: ProviderCapabilities;
 export interface ProviderAdapter {
+    readonly capabilities: ProviderCapabilities;
     generateReply(input: ProviderInput, options?: ProviderGenerateOptions): Promise<ProviderReply>;
     dispose?(): Promise<void>;
 }

package/dist/providers/provider-adapter.js

@@ -1 +1,44 @@
-export {};
+export const SHARED_HOST_ATTACHMENT_METADATA_FALLBACK = Object.freeze({
+    support: 'metadata-only',
+    delivery: 'prompt-text-attachment-metadata',
+});
+function resolveImageInputSupport(transport, sharedHostFallback) {
+    if (transport.support === 'supported') {
+        return {
+            support: 'supported',
+            reason: 'real-media-delivered',
+        };
+    }
+    if (transport.reason === 'host-policy-blocked') {
+        return {
+            support: 'not-supported',
+            reason: 'host-policy-blocked',
+        };
+    }
+    return {
+        support: sharedHostFallback.support,
+        reason: 'shared-host-attachment-metadata-fallback',
+    };
+}
+export function createHostedProviderCapabilities(params) {
+    const sharedHostFallback = params.sharedHostFallback ?? SHARED_HOST_ATTACHMENT_METADATA_FALLBACK;
+    const transport = Object.freeze({
+        ...params.imageInputTransport,
+        delivery: Object.freeze([...params.imageInputTransport.delivery]),
+    });
+    return Object.freeze({
+        imageInput: Object.freeze({
+            ...resolveImageInputSupport(transport, sharedHostFallback),
+            sharedHostFallback,
+            transport,
+        }),
+    });
+}
+export const TEXT_ONLY_HOSTED_PROVIDER_CAPABILITIES = createHostedProviderCapabilities({
+    imageInputTransport: {
+        source: 'transport-derived',
+        support: 'not-supported',
+        reason: 'transport-does-not-deliver-real-media',
+        delivery: [],
+    },
+});

package/dist/state-paths.d.ts

@@ -1,4 +1,11 @@
 export declare function normalizeManagedRuntimeKey(serverUrl: string): string;
+export type ManagedDaemonEndpoint = {
+    kind: 'named-pipe';
+    address: string;
+} | {
+    kind: 'unix-socket';
+    address: string;
+};
 export declare function resolveSingleAgentStateRoot(env?: NodeJS.ProcessEnv, resolvedHomeDir?: string, agentKey?: string): string;
 export declare function resolveManagedRuntimeRoot(serverUrl: string, env?: NodeJS.ProcessEnv, resolvedHomeDir?: string): string;
 /**
@@ -7,16 +14,17 @@ export declare function resolveManagedRuntimeRoot(serverUrl: string, env?: NodeJ
  */
 export declare function resolveUpdateCheckCachePath(env?: NodeJS.ProcessEnv, resolvedHomeDir?: string): string;
 export declare function resolveManagedStateRoot(rootPath: string): string;
-export declare function resolveManagedDaemonSocketPath(rootPath: string): string;
+export declare function resolveManagedDaemonEndpoint(rootPath: string, platform?: NodeJS.Platform): ManagedDaemonEndpoint;
+export declare function resolveManagedDaemonSocketPath(rootPath: string, platform?: NodeJS.Platform): string;
 export declare function resolveManagedDaemonLogPath(rootPath: string): string;
 export declare function resolveManagedRuntimeSettingsPath(rootPath: string): string;
 export declare function resolveManagedBootstrapLockPath(rootPath: string): string;
 export declare function resolveLocalConfigAgentStateRoot(rootPath: string, agentKey: string): string;
-export declare function resolveAgentCursorPath(stateRootDir: string, agentId: string): string;
 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 resolveCompactionStatePath(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

@@ -1,12 +1,13 @@
 import { createHash } from 'node:crypto';
 import { homedir } from 'node:os';
-import { dirname, join, resolve } from 'node:path';
+import { dirname, join, posix, resolve, win32 } from 'node:path';
 const SINGLE_AGENT_HOME_ROOT = '.borgee';
 const AGENTS_HOST_ROOT = 'agents-host';
 const SINGLE_AGENT_NAMESPACE = 'single-agent';
 const MANAGED_RUNTIME_NAMESPACE = 'managed';
 const MANAGED_STATE_DIRNAME = '.state';
 const MANAGED_DAEMON_SOCKET_FILENAME = 'ctl.sock';
+const MANAGED_DAEMON_PIPE_PREFIX = '\\\\.\\pipe\\borgee-agents-host-managed-';
 const MANAGED_DAEMON_LOG_FILENAME = 'daemon.log';
 const MANAGED_RUNTIME_SETTINGS_FILENAME = 'managed-runtime-settings.json';
 const MANAGED_BOOTSTRAP_LOCK_DIRNAME = '.bootstrap.lock';
@@ -95,8 +96,26 @@ export function resolveUpdateCheckCachePath(env = process.env, resolvedHomeDir =
 export function resolveManagedStateRoot(rootPath) {
     return join(resolve(rootPath), MANAGED_STATE_DIRNAME);
 }
-export function resolveManagedDaemonSocketPath(rootPath) {
-    return join(resolve(rootPath), MANAGED_DAEMON_SOCKET_FILENAME);
+export function resolveManagedDaemonEndpoint(rootPath, platform = process.platform) {
+    const pathApi = platform === 'win32' ? win32 : posix;
+    const resolvedRoot = pathApi.resolve(rootPath);
+    if (platform === 'win32') {
+        const rootHash = createHash('sha256')
+            .update(resolvedRoot.toLowerCase())
+            .digest('hex')
+            .slice(0, 24);
+        return {
+            kind: 'named-pipe',
+            address: `${MANAGED_DAEMON_PIPE_PREFIX}${rootHash}`,
+        };
+    }
+    return {
+        kind: 'unix-socket',
+        address: posix.join(resolvedRoot, MANAGED_DAEMON_SOCKET_FILENAME),
+    };
+}
+export function resolveManagedDaemonSocketPath(rootPath, platform = process.platform) {
+    return resolveManagedDaemonEndpoint(rootPath, platform).address;
 }
 export function resolveManagedDaemonLogPath(rootPath) {
     return join(resolve(rootPath), MANAGED_DAEMON_LOG_FILENAME);
@@ -110,9 +129,6 @@ export function resolveManagedBootstrapLockPath(rootPath) {
 export function resolveLocalConfigAgentStateRoot(rootPath, agentKey) {
     return join(resolveManagedStateRoot(rootPath), `${sanitizeStateRootLabel(agentKey)}-${hashStateRootKey(agentKey)}`);
 }
-export function resolveAgentCursorPath(stateRootDir, agentId) {
-    return join(stateRootDir, `bpp-cursor-${encodeSegment(agentId)}.json`);
-}
 export function resolveSharedProtocolKickoffDecisionPath(stateRootDir, channelId, anchorMessageId) {
     return join(dirname(resolve(stateRootDir)), 'protocol-kickoff-decisions', `${encodeSegment(channelId)}--${encodeSegment(anchorMessageId)}.json`);
 }
@@ -125,6 +141,9 @@ export function resolveConnectionsStatePath(stateRootDir) {
 export function resolveAttentionStatePath(stateRootDir, channelId) {
     return join(stateRootDir, 'attention-state', `${encodeSegment(channelId)}.json`);
 }
+export function resolveCompactionStatePath(stateRootDir, channelId) {
+    return join(stateRootDir, 'compaction-state', `${encodeSegment(channelId)}.json`);
+}
 export function resolveAuthorizationAuditPath(stateRootDir) {
     return join(stateRootDir, 'authorization-audit.jsonl');
 }

package/dist/task-thread-resolution.d.ts

@@ -1,10 +1,11 @@
 import type { ChatControlPlane } from './chat/chat-control-plane.js';
 import type { Task } from './types.js';
+type TaskThreadResolutionControlPlane = Pick<ChatControlPlane, 'getTask' | 'listChannels' | 'listTasks'>;
 interface WaitForTaskForThreadOptions {
     preferredTaskId?: string;
     attempts?: number;
     delayMs?: number;
 }
-export declare function findTaskForThread(controlPlane: ChatControlPlane, threadId: string, preferredTaskId?: string): Promise<Task | null>;
-export declare function waitForTaskForThread(controlPlane: ChatControlPlane, threadId: string, options?: WaitForTaskForThreadOptions): Promise<Task | null>;
+export declare function findTaskForThread(controlPlane: TaskThreadResolutionControlPlane, threadId: string, preferredTaskId?: string): Promise<Task | null>;
+export declare function waitForTaskForThread(controlPlane: TaskThreadResolutionControlPlane, threadId: string, options?: WaitForTaskForThreadOptions): Promise<Task | null>;
 export {};