ds-harness-remote 0.4.26 → 0.5.0

package/dist/acp/virtual-harness.js

@@ -0,0 +1,1556 @@
+import { ACP_TOOL_CALL_ENDPOINTS, ACP_TOOL_STREAM_ENDPOINTS } from '@dsh-remote/protocol';
+import { parseAcpImage, acpImageContent, acpImageLimits } from './image-content.js';
+import { AgentAcpClient } from '@dsh-remote/client-core';
+const CURSOR_SESSION_PREFIX = 'cursor:';
+const ACP_SESSION_PREFIX = 'acp:';
+const CURSOR_WORKSPACE_PREFIX = 'cursor:cwd:';
+const AGY_WORKSPACE_PREFIX = 'antigravity:cwd:';
+const CURSOR_PROVIDER = 'cursor';
+const CURSOR_MODEL = 'cursor';
+/** Build a backend-scoped virtual Workspace id for an absolute Host cwd. */
+export function acpCwdWorkspaceId(path, backend) {
+    if (backend !== 'cursor' && backend !== 'antigravity')
+        throw new Error('An explicit ACP workspace backend is required.');
+    return `${backend === 'antigravity' ? AGY_WORKSPACE_PREFIX : CURSOR_WORKSPACE_PREFIX}${encodeURIComponent(path)}`;
+}
+export function createAcpWorkspaceView(path, backend, title) {
+    const now = new Date().toISOString();
+    const label = title?.trim() || path.split(/[\\/]/).filter(Boolean).at(-1) || path;
+    return {
+        workspaceId: acpCwdWorkspaceId(path, backend),
+        path,
+        title: label,
+        sessionIds: [],
+        sessionCount: 0,
+        createdAt: now,
+        updatedAt: now,
+    };
+}
+/** Discover ACP virtual workspaces visible on the Host. */
+export async function discoverAcpVirtualWorkspaces(client, backend, signal) {
+    if (client?.listWorkspaces !== undefined) {
+        try {
+            const items = await client.listWorkspaces(backend, signal);
+            if (Array.isArray(items) && items.length > 0) {
+                return items
+                    .filter(item => typeof item?.path === 'string' && item.path.trim() !== '')
+                    .map(item => {
+                    const view = createAcpWorkspaceView(item.path, backend, item.title);
+                    if (typeof item.sessionCount === 'number')
+                        view.sessionCount = item.sessionCount;
+                    return view;
+                });
+            }
+        }
+        catch {
+            // Discovery is optional; an unavailable Host returns no workspaces.
+        }
+    }
+    return [];
+}
+/**
+ * Browser-safe, in-memory Harness projection for the independent Agent ACP domain. Projects
+ * cwd workspaces and ACP sessions onto the native DSH Workspace / Session /
+ * Composer surface without writing DSH SessionStore.
+ */
+export class AcpVirtualHarness {
+    client;
+    host;
+    backend;
+    api;
+    workspaceById = new Map();
+    sessions = new Map();
+    workspaceStreams = new Set();
+    controlStreams = new Set();
+    eventStreams = new Map();
+    rcMuxStreams = new Set();
+    rcHostStreams = new Set();
+    follows = new Set();
+    pendingApprovals = new Map();
+    selectedWorkspaceId;
+    selectedModels = new Map();
+    lastProjectionSeq = 0;
+    imageAttachments = new Map();
+    closed = false;
+    constructor(client, host, backend = 'cursor') {
+        this.client = client;
+        this.host = host;
+        this.backend = backend;
+        this.api = this.createApiProxy();
+    }
+    static remote(core, host, backend = 'cursor', capabilities = []) {
+        return new AcpVirtualHarness(new AgentAcpClient(core, capabilities), host, backend);
+    }
+    async workspaces() {
+        return [...this.workspaceById.values()];
+    }
+    backendLabel() {
+        return this.backend === 'antigravity' ? 'Antigravity' : 'Cursor';
+    }
+    async selectWorkspace(workspaceId) {
+        const workspace = this.workspaceById.get(workspaceId) ?? recreateWorkspaceFromId(workspaceId, this.backend);
+        if (workspace === undefined)
+            throw new Error(`The selected ${this.backendLabel()} workspace is no longer available.`);
+        this.workspaceById.set(workspace.workspaceId, workspace);
+        this.selectedWorkspaceId = workspace.workspaceId;
+        await this.discoverAndAttachSessions(workspace);
+        if (workspace.sessionIds.length === 0) {
+            await this.ensureInitialSession(workspace);
+        }
+        this.publishWorkspaceBaseline();
+        return this.workspaceById.get(workspace.workspaceId) ?? workspace;
+    }
+    async selectOrCreateWorkspace(path) {
+        const trimmed = path.trim();
+        if (trimmed.length === 0)
+            throw new Error(`A ${this.backendLabel()} working directory is required.`);
+        const existing = [...this.workspaceById.values()].find(item => item.path === trimmed);
+        const workspace = existing ?? createAcpWorkspaceView(trimmed, this.backend);
+        this.workspaceById.set(workspace.workspaceId, workspace);
+        this.selectedWorkspaceId = workspace.workspaceId;
+        await this.discoverAndAttachSessions(workspace);
+        if (workspace.sessionIds.length === 0) {
+            await this.ensureInitialSession(workspace);
+        }
+        this.publishWorkspaceBaseline();
+        return this.workspaceById.get(workspace.workspaceId) ?? workspace;
+    }
+    async preferredSessionId() {
+        const selected = this.selectedWorkspaceId === undefined
+            ? undefined
+            : this.workspaceById.get(this.selectedWorkspaceId);
+        const sessionIds = selected?.sessionIds ?? [];
+        let bestSessionId;
+        let bestUpdatedAt = -1;
+        for (const sessionId of sessionIds) {
+            const session = this.sessions.get(sessionId);
+            if (session !== undefined && !session.running && !session.blank && session.updatedAt > bestUpdatedAt) {
+                bestUpdatedAt = session.updatedAt;
+                bestSessionId = sessionId;
+            }
+        }
+        if (bestSessionId !== undefined)
+            return bestSessionId;
+        for (const sessionId of sessionIds) {
+            const session = this.sessions.get(sessionId);
+            if (session !== undefined && !session.running)
+                return sessionId;
+        }
+        return sessionIds[0] ?? sessionIds.at(-1);
+    }
+    async invoke(request) {
+        const result = await this.dispatch(`${request.namespace}/${request.method}`, { args: request.args }, request.signal ?? new AbortController().signal);
+        if (result.ok)
+            return result.value;
+        throw Object.assign(new Error(result.error.message), {
+            isDSHRemoteError: true,
+            code: result.error.code,
+            details: result.error.details,
+        });
+    }
+    async dispatch(endpoint, payload, signal) {
+        try {
+            const args = carrierArgs(payload);
+            if (ACP_TOOL_CALL_ENDPOINTS.some(item => item === endpoint)) {
+                if (!this.client.workspaceToolCall)
+                    return business(failure('method-not-found', 'The Host does not support ACP workspace tools.'));
+                const sessionId = requiredString(args.workspaceFileScopeId ?? args.agentId ?? args.sessionId, 'sessionId');
+                return business(await this.client.workspaceToolCall(nativeAcpId(sessionId, this.backend), this.backend, endpoint, args, signal));
+            }
+            switch (endpoint) {
+                case '$events/result': return business(await this.answerRemoteEvent(args, signal));
+                case 'workspace/list': return business(success({
+                    items: this.visibleWorkspaces().map(nativeWorkspace),
+                    archivedSessionIds: [],
+                    pinnedSessionIds: [],
+                }));
+                case 'workspace/create': return business(await this.createWorkspace(requestArg(args)));
+                case 'workspace/rename': return business(await this.renameWorkspace(requestArg(args)));
+                case 'workspace/delete': return business(failure('workspace-read-only', `${this.backendLabel()} virtual Workspaces cannot be deleted from Desktop yet.`));
+                case 'workspace/insertBefore': return business({
+                    workspaceIds: this.visibleWorkspaces().map(item => item.workspaceId),
+                });
+                case 'workspace/insertSessionBefore': return business(await this.workspaceForSession(requestArg(args)));
+                case 'workspace/archiveSession': return business(await this.archiveSession(requestArg(args)));
+                case 'session/list': return business(success({ items: await this.handleSessionList() }));
+                case 'session/search': return business(success({ items: [], hasMore: false }));
+                case 'session/create': return business(await this.createSession(requestArg(args), signal));
+                case 'session/fork': return business(failure('bad-request', `${this.backendLabel()} Remote does not support session fork yet.`));
+                case 'session/history': return business(await this.sessionHistory(requestArg(args)));
+                case 'session/page': return business(await this.sessionPage(requestArg(args)));
+                case 'session/prompt': return business(await this.prompt(requestArg(args), signal));
+                case 'session/cancel': return business(await this.cancel(requestArg(args), signal));
+                case 'session/rename': return business(await this.renameSession(requestArg(args)));
+                case 'session/updateQueue': return business(failure('queue-item-not-found', `${this.backendLabel()} does not expose a DSH inbox queue.`));
+                case 'session/attachment': return business(await this.attachment(requestArg(args)));
+                case 'session/modelCatalog': {
+                    const sessionId = await this.preferredSessionId();
+                    if (this.backend !== 'antigravity' || !sessionId)
+                        return business(success(modelCatalog(this.backend)));
+                    const models = await this.hostSessionModels(sessionId);
+                    return business(success({ default: models.current, routableProviders: models.routable ? [models.current.provider] : [], groups: models.groups, failures: models.failures }));
+                }
+                case 'session/models': {
+                    const rawId = extractSessionId(requestArg(args));
+                    nativeAcpId(rawId, this.backend);
+                    if (this.backend === 'antigravity')
+                        return business(success(await this.hostSessionModels(rawId)));
+                    const catalog = modelCatalog(this.backend);
+                    return business(success({
+                        current: this.modelSelection(rawId),
+                        routable: true,
+                        groups: catalog.groups,
+                        failures: [],
+                    }));
+                }
+                case 'session/selectModel': return business(await this.selectModel(requestArg(args)));
+                case 'session/canOpenWorkspacePath': return business(this.selectedWorkspaceId !== undefined);
+                case 'session/openWorkspacePath': return business(failure('bad-request', `Opening Host paths is unavailable in ${this.backendLabel()} mode.`));
+                case 'host/describe': return business(success(this.describeHost()));
+                case 'host/listDirectory':
+                case 'directoryPicker/list': return business(await this.listDirectory(requestArg(args), signal));
+                case 'skills/list': return business(success({ items: [] }));
+                case 'commands/list': return business([]);
+                case 'commands/execute': return business(undefined);
+                default:
+                    return fail('method-not-found', `${this.backendLabel()} virtual Harness does not implement ${endpoint}.`);
+            }
+        }
+        catch (error) {
+            return failFrom(error);
+        }
+    }
+    async open(endpoint, payload, signal) {
+        const args = carrierArgs(payload);
+        if (ACP_TOOL_STREAM_ENDPOINTS.some(item => item === endpoint)) {
+            const sessionId = requiredString(args.workspaceFileScopeId ?? args.agentId ?? args.sessionId, 'sessionId');
+            const queue = new AsyncValueQueue(signal);
+            const stream = await this.client.openStream(nativeAcpId(sessionId, this.backend), frame => {
+                if (frame.frame.method === 'dsh/workspaceTool')
+                    queue.push(record(frame.frame.params).value);
+            }, () => queue.close(), signal, { backend: this.backend, endpoint: endpoint, args });
+            return queue.iterate(() => { void stream.close().catch(() => undefined); });
+        }
+        if (endpoint === 'workspace/follow')
+            return this.workspaceFollow(signal);
+        if (endpoint === 'session/control')
+            return this.sessionControl(signal);
+        if (endpoint === 'session/follow')
+            return this.sessionFollow(requestArg(args), signal);
+        if (endpoint === '$events')
+            return this.remoteEvents(signal);
+        throw Object.assign(new Error(`${this.backendLabel()} virtual Harness does not implement stream ${endpoint}.`), {
+            isDSHRemoteError: true,
+            code: 'method-not-found',
+            details: {},
+        });
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        for (const stream of this.workspaceStreams)
+            stream.close();
+        for (const stream of this.controlStreams)
+            stream.close();
+        for (const stream of this.eventStreams.values())
+            stream.close();
+        for (const stream of this.rcMuxStreams)
+            stream.close();
+        for (const stream of this.rcHostStreams)
+            stream.close();
+        this.workspaceStreams.clear();
+        this.controlStreams.clear();
+        this.eventStreams.clear();
+        this.rcMuxStreams.clear();
+        this.rcHostStreams.clear();
+        const follows = [...this.follows];
+        this.follows.clear();
+        for (const follow of follows) {
+            follow.queue.close();
+            await follow.close?.().catch(() => undefined);
+        }
+        this.pendingApprovals.clear();
+        this.imageAttachments.clear();
+    }
+    visibleWorkspaces() {
+        if (this.selectedWorkspaceId === undefined)
+            return [...this.workspaceById.values()];
+        const selected = this.workspaceById.get(this.selectedWorkspaceId);
+        if (selected === undefined)
+            return [...this.workspaceById.values()];
+        return [
+            selected,
+            ...[...this.workspaceById.values()].filter(item => item.workspaceId !== selected.workspaceId),
+        ];
+    }
+    async createWorkspace(request) {
+        const path = string(request.path)?.trim();
+        if (path === undefined || path.length === 0)
+            return failure('bad-request', 'A Cursor working directory is required.');
+        const workspace = await this.selectOrCreateWorkspace(path);
+        this.publishWorkspaceBaseline();
+        return success({ workspace: nativeWorkspace(workspace), created: true });
+    }
+    async renameWorkspace(request) {
+        const workspaceId = requiredString(request.workspaceId, 'workspaceId');
+        const title = string(request.title)?.trim();
+        const workspace = this.workspaceById.get(workspaceId);
+        if (workspace === undefined)
+            return failure('workspace-not-found', 'The Cursor virtual Workspace was not found.');
+        if (title === undefined || title.length === 0)
+            return failure('bad-request', 'A Workspace name is required.');
+        const next = { ...workspace, title, updatedAt: new Date().toISOString() };
+        this.workspaceById.set(workspaceId, next);
+        this.publishWorkspaceBaseline();
+        return success({ workspace: nativeWorkspace(next) });
+    }
+    async workspaceForSession(request) {
+        const sessionId = string(request.sessionId);
+        const workspace = [...this.workspaceById.values()].find(item => sessionId !== undefined && item.sessionIds.includes(sessionId));
+        return workspace === undefined
+            ? failure('workspace-not-found', 'The Cursor virtual Workspace was not found.')
+            : success({ workspace: nativeWorkspace(workspace) });
+    }
+    async archiveSession(request) {
+        const sessionId = extractSessionId(request);
+        this.sessions.delete(sessionId);
+        for (const [workspaceId, workspace] of this.workspaceById) {
+            if (!workspace.sessionIds.includes(sessionId))
+                continue;
+            const sessionIds = workspace.sessionIds.filter(id => id !== sessionId);
+            this.workspaceById.set(workspaceId, {
+                ...workspace,
+                sessionIds,
+                sessionCount: sessionIds.length,
+                updatedAt: new Date().toISOString(),
+            });
+        }
+        this.emitRemoteEvent('api-session/removed', [sessionId]);
+        this.publishWorkspaceBaseline();
+        return success({ archivedSessionIds: [sessionId] });
+    }
+    async createSession(request, signal) {
+        const workspaceId = string(request.workspaceId) ?? this.selectedWorkspaceId;
+        const workspace = workspaceId === undefined ? undefined : this.workspaceById.get(workspaceId);
+        const cwd = string(request.cwd) ?? workspace?.path;
+        if (cwd === undefined)
+            return failure('workspace-not-found', 'The Cursor virtual Workspace was not found.');
+        const requestedSessionId = string(request.sessionId);
+        const reusable = requestedSessionId === undefined ? undefined : this.sessions.get(requestedSessionId);
+        if (reusable !== undefined && reusable.cwd === cwd && reusable.blank && !reusable.running) {
+            return success({ sessionId: reusable.sessionId });
+        }
+        const created = await this.client.createSession(cwd, 'agent', this.backend, signal);
+        if (this.backend === 'antigravity' && this.sessions.has(`${ACP_SESSION_PREFIX}${created.sessionId}`)) {
+            return failure('session-already-exists', 'The backend returned an existing conversation for a new Session.');
+        }
+        const session = this.registerSession(created.sessionId, cwd, workspace?.title);
+        this.attachSessionToWorkspace(cwd, session.sessionId);
+        this.publishWorkspaceBaseline();
+        const seq = this.nextProjectionSeq();
+        this.emitRemoteEvent('api-session/added', [this.sessionSummary(session, seq)]);
+        this.publishProjection(session.sessionId, 'title', session.title ?? this.backendLabel(), seq);
+        return success({ sessionId: session.sessionId });
+    }
+    ensureSessionRegistered(sessionId) {
+        let session = this.sessions.get(sessionId);
+        if (session !== undefined)
+            return session;
+        if (this.backend === 'antigravity' && sessionId.startsWith(ACP_SESSION_PREFIX)) {
+            const acpSessionId = sessionId.slice(ACP_SESSION_PREFIX.length);
+            const workspace = this.selectedWorkspaceId !== undefined ? this.workspaceById.get(this.selectedWorkspaceId) : undefined;
+            const cwd = workspace?.path ?? '/';
+            session = this.registerSession(acpSessionId, cwd, 'Antigravity', Date.now(), Date.now(), false);
+            if (workspace && !workspace.sessionIds.includes(sessionId)) {
+                workspace.sessionIds.unshift(sessionId);
+                workspace.sessionCount = workspace.sessionIds.length;
+                this.publishWorkspaceBaseline();
+            }
+            return session;
+        }
+        return undefined;
+    }
+    async prompt(request, signal) {
+        const sessionId = extractSessionId(request);
+        const session = this.ensureSessionRegistered(sessionId) ?? this.sessions.get(sessionId);
+        if (session === undefined)
+            return failure('session-not-found', 'The Session was not found.');
+        await this.hydrateSession(session);
+        const text = extractPromptText(array(request.content));
+        let images;
+        try {
+            images = array(request.content).filter(part => record(part).type === 'image').map(parseAcpImage);
+            if (images.length > 4 || (images.length > 0 && this.backend !== 'antigravity') || array(request.content).some(part => !['text', 'image'].includes(String(record(part).type))))
+                throw new Error('Unsupported ACP content.');
+        }
+        catch {
+            return failure('attachment-error', 'Invalid or unsupported image attachment.');
+        }
+        if (text === undefined && images.length === 0)
+            return failure('attachment-error', 'A prompt or image is required.');
+        const imageBlocks = images.map(image => acpImageContent(image, `agy-image:${crypto.randomUUID()}.${image.mimeType === 'image/jpeg' ? 'jpg' : image.mimeType.slice(6)}`));
+        this.cacheImageAttachments(sessionId, imageBlocks);
+        const requestId = typeof request.requestId === 'string' && request.requestId.length > 0
+            ? request.requestId
+            : undefined;
+        await this.ensureFollow(session);
+        const follow = [...this.follows].find(f => f.sessionId === sessionId);
+        if (follow !== undefined) {
+            follow.turn += 1;
+            follow.stepOpen = true;
+            this.pushEvent(follow, 'turn/start', { turn: follow.turn });
+            this.pushEvent(follow, 'step/start', { turn: follow.turn, step: 1 });
+            this.pushEvent(follow, 'user/message', {
+                id: `user:${Date.now()}`,
+                role: 'user',
+                content: [...(text ? [{ type: 'text', text }] : []), ...imageBlocks],
+                source: requestId ? { kind: 'user', rpcId: requestId } : { kind: 'user' },
+            });
+        }
+        session.blank = false;
+        session.running = true;
+        session.updatedAt = Date.now();
+        this.emitRemoteEvent('api-session/status', [sessionId, true]);
+        await this.client.prompt(session.acpSessionId, text ?? '', signal, images, this.backend);
+        return success({ accepted: true });
+    }
+    async cancel(request, signal) {
+        const sessionId = extractSessionId(request);
+        const session = this.ensureSessionRegistered(sessionId) ?? this.sessions.get(sessionId);
+        if (session === undefined)
+            return failure('session-not-found', 'The Session was not found.');
+        await this.client.cancel(session.acpSessionId, signal);
+        session.running = false;
+        this.emitRemoteEvent('api-session/status', [sessionId, false]);
+        return success({ accepted: true });
+    }
+    async renameSession(request) {
+        const sessionId = extractSessionId(request);
+        const title = string(request.title)?.trim();
+        const session = this.ensureSessionRegistered(sessionId) ?? this.sessions.get(sessionId);
+        if (session === undefined)
+            return failure('session-not-found', 'The Session was not found.');
+        if (title === undefined)
+            return failure('bad-request', 'A Session title is required.');
+        session.title = title;
+        session.titleOverridden = true;
+        session.updatedAt = Date.now();
+        this.publishProjection(sessionId, 'title', title);
+        return success({ sessionId });
+    }
+    cacheImageAttachments(sessionId, content) {
+        for (const value of content) {
+            const block = record(value);
+            const attachment = record(block.attachment);
+            if (block.type === 'image' && typeof attachment.attachmentId === 'string' && typeof block.data === 'string') {
+                this.imageAttachments.set(attachment.attachmentId, { sessionId, attachment, data: block.data });
+            }
+        }
+    }
+    async attachment(request) {
+        const sessionId = extractSessionId(request);
+        const attachmentId = string(request.attachmentId);
+        const session = this.ensureSessionRegistered(sessionId);
+        if (this.backend !== 'antigravity' || session === undefined || !attachmentId?.startsWith('agy-image:'))
+            return failure('attachment-error', 'The image is not referenced by this AGY Session.');
+        await this.hydrateSession(session);
+        const cached = this.imageAttachments.get(attachmentId);
+        return cached?.sessionId === sessionId ? success({ attachment: cached.attachment, data: cached.data }) : failure('attachment-error', 'The AGY image is unavailable or expired.');
+    }
+    async hydrateSession(session) {
+        if (this.backend !== 'antigravity' || session.blank || session.events.length > 0)
+            return;
+        let events = [];
+        if (this.client.loadSessionHistory !== undefined) {
+            try {
+                events = await this.client.loadSessionHistory(session.sessionId, this.backend);
+            }
+            catch {
+                // Keep the projection empty until remote history is available.
+            }
+        }
+        if (events.length > 0) {
+            session.events = events;
+            session.blank = false;
+            session.updatedAt = Date.now();
+            for (const event of session.events)
+                this.cacheImageAttachments(session.sessionId, array(record(event.event.data).content ?? record(record(event.event.data).message).content));
+        }
+    }
+    async sessionHistory(request) {
+        const sessionId = extractSessionId(request);
+        const session = this.ensureSessionRegistered(sessionId) ?? this.sessions.get(sessionId);
+        if (session === undefined)
+            return failure('session-not-found', 'The Session was not found.');
+        await this.hydrateSession(session);
+        const page = this.historyPage(session, {
+            beforeSeq: optionalInteger(request.beforeSeq),
+            limit: optionalPositiveInteger(request.maxMessages) ?? 50,
+        });
+        return success({
+            ...page,
+            events: page.records.map(entry => ({ event: entry.event })),
+            projections: {
+                asOfSeq: page.cursor,
+                values: {
+                    title: session.title ?? (this.backend === 'antigravity' ? 'Antigravity' : 'Cursor'),
+                    sessionListMetadata: { blank: session.blank && session.events.length === 0, lastPromptAt: null },
+                    modelSelection: this.modelSelectionProjection(sessionId),
+                    imageLimits: acpImageLimits(this.backend),
+                },
+            },
+        });
+    }
+    async sessionPage(request) {
+        const sessionId = extractSessionId(request);
+        const session = this.ensureSessionRegistered(sessionId) ?? this.sessions.get(sessionId);
+        if (session === undefined)
+            return failure('session-not-found', 'The Session was not found.');
+        await this.hydrateSession(session);
+        const page = this.historyPage(session, {
+            beforeSeq: optionalInteger(request.beforeSeq),
+            throughSeq: optionalInteger(request.throughSeq),
+            limit: optionalPositiveInteger(request.limit) ?? optionalPositiveInteger(request.maxMessages) ?? 50,
+        });
+        return success({ records: page.records, hasMore: page.hasMore });
+    }
+    historyPage(session, options = {}) {
+        const lastSessionSeq = session.events.at(-1)?.event.seq ?? -1;
+        const throughSeq = Math.min(options.throughSeq ?? lastSessionSeq, lastSessionSeq);
+        const endSeq = Math.min(throughSeq, options.beforeSeq === undefined ? throughSeq : options.beforeSeq - 1);
+        const window = endSeq < 0 ? [] : session.events.filter(entry => entry.event.seq <= endSeq);
+        const limit = options.limit ?? 50;
+        const records = window.slice(Math.max(0, window.length - limit));
+        const cursor = records.at(-1)?.event.seq ?? -1;
+        return {
+            header: {
+                version: 3,
+                id: session.sessionId,
+                createdAt: session.createdAt,
+                cwd: session.cwd,
+                isSeeded: false,
+            },
+            cursor,
+            nextTurn: Math.max(0, ...session.events.map(entry => isRecord(entry.event.data) && typeof entry.event.data.turn === 'number' ? entry.event.data.turn : 0)) + 1,
+            records,
+            hasMore: window.length > records.length,
+            ...(session.running ? { activeTurnId: 'cursor-live' } : {}),
+            assistantStream: { revision: 0 },
+        };
+    }
+    describeHost() {
+        const workspace = this.selectedWorkspaceId === undefined
+            ? undefined
+            : this.workspaceById.get(this.selectedWorkspaceId);
+        const name = this.backendLabel();
+        return {
+            version: `${name} Remote`,
+            cwd: workspace?.path ?? '',
+            home: workspace?.path ?? '',
+            provider: name,
+            model: modelCatalog(this.backend).default.model,
+            attachedSessions: this.sessions.size,
+            canOpenPath: workspace !== undefined,
+        };
+    }
+    async listDirectory(request, signal) {
+        const workspace = this.selectedWorkspaceId === undefined
+            ? undefined
+            : this.workspaceById.get(this.selectedWorkspaceId);
+        if (workspace === undefined)
+            return failure('workspace-not-found', `The ${this.backendLabel()} virtual Workspace was not found.`);
+        const path = string(request.path) ?? workspace.path;
+        return success(await this.client.listDirectory(path, signal));
+    }
+    async answerRemoteEvent(args, signal) {
+        const eventId = string(args.eventId);
+        const outcome = record(args.outcome);
+        if (eventId === undefined)
+            throw new Error(`The ${this.backendLabel()} approval result is missing its event id.`);
+        const pending = this.pendingApprovals.get(eventId);
+        if (pending === undefined)
+            return undefined;
+        this.pendingApprovals.delete(eventId);
+        const decision = outcome.kind === 'result' && outcome.value === 'allowed-once'
+            ? 'allow-once'
+            : outcome.kind === 'result' && outcome.value === 'cancelled'
+                ? 'cancel'
+                : 'reject-once';
+        await this.client.respond(pending.requestHandle, decision, undefined, signal);
+        return undefined;
+    }
+    async workspaceFollow(signal) {
+        const queue = new AsyncValueQueue(signal);
+        this.workspaceStreams.add(queue);
+        queue.push({
+            type: 'baseline',
+            value: {
+                items: this.visibleWorkspaces().map(nativeWorkspace),
+                archivedSessionIds: [],
+                pinnedSessionIds: [],
+            },
+        });
+        return queue.iterate(() => this.workspaceStreams.delete(queue));
+    }
+    async sessionControl(signal) {
+        const queue = new AsyncValueQueue(signal);
+        this.controlStreams.add(queue);
+        // Session Controller treats the first control frame as the opening
+        // snapshot. Without it the Client-side RemoteSnapshotStream never moves
+        // to `ready`, so a workspace selected through the Remote modal remains
+        // stuck on the empty shell after the page reload.
+        queue.push({ type: 'baseline', value: { projections: {} } });
+        return queue.iterate(() => this.controlStreams.delete(queue));
+    }
+    async remoteEvents(signal) {
+        const id = `cursor-events:${Date.now()}:${Math.random()}`;
+        const queue = new AsyncValueQueue(signal);
+        this.eventStreams.set(id, queue);
+        const workspace = this.selectedWorkspaceId === undefined
+            ? undefined
+            : this.workspaceById.get(this.selectedWorkspaceId);
+        queue.push({
+            type: 'ready',
+            clientId: id,
+            host: { home: workspace?.path ?? '/' },
+        });
+        return queue.iterate(() => this.eventStreams.delete(id));
+    }
+    async sessionFollow(request, signal) {
+        const sessionId = extractSessionId(request);
+        const session = this.ensureSessionRegistered(sessionId) ?? this.sessions.get(sessionId);
+        if (session === undefined)
+            throw new Error('The Session was not found.');
+        await this.hydrateSession(session);
+        const history = this.historyPage(session, {
+            limit: optionalPositiveInteger(request.maxMessages) ?? 50,
+        });
+        const queue = new AsyncValueQueue(signal);
+        const follow = {
+            sessionId,
+            acpSessionId: session.acpSessionId,
+            queue,
+            nextSeq: session.events.length,
+            turn: Math.max(0, ...session.events.map(entry => (isRecord(entry.event.data) && typeof entry.event.data.turn === 'number' ? entry.event.data.turn : 0))),
+            stepOpen: session.running,
+            streamActive: false,
+            assistantStreamRevision: 0,
+            accumulatedText: '',
+            activeToolCalls: new Set(),
+        };
+        this.follows.add(follow);
+        queue.push({
+            type: 'snapshot',
+            header: history.header,
+            cursor: history.cursor,
+            records: history.records,
+            hasMore: history.hasMore,
+            projections: {
+                asOfSeq: history.cursor,
+                values: {
+                    title: session.title ?? (this.backend === 'antigravity' ? 'Antigravity' : 'Cursor'),
+                    sessionListMetadata: { blank: session.blank && session.events.length === 0, lastPromptAt: null },
+                    modelSelection: this.modelSelectionProjection(sessionId),
+                    imageLimits: acpImageLimits(this.backend),
+                },
+            },
+            assistantStream: { revision: 0 },
+        });
+        try {
+            const stream = await this.client.openStream(session.acpSessionId, frame => this.acceptAcpFrame(follow, frame), () => {
+                session.running = false;
+                this.emitRemoteEvent('api-session/status', [sessionId, false]);
+                this.closeFollowAfterRemoteStreamClosed(follow);
+            }, signal);
+            follow.close = () => stream.close();
+        }
+        catch (error) {
+            this.follows.delete(follow);
+            queue.close();
+            throw error;
+        }
+        return queue.iterate(() => {
+            this.follows.delete(follow);
+            void follow.close?.().catch(() => undefined);
+        });
+    }
+    async ensureFollow(session) {
+        if ([...this.follows].some(follow => follow.sessionId === session.sessionId))
+            return;
+        // Native UI opens session/follow; prompts before follow still work via Host stream open on demand.
+        const controller = new AbortController();
+        const queue = new AsyncValueQueue(controller.signal);
+        const follow = {
+            sessionId: session.sessionId,
+            acpSessionId: session.acpSessionId,
+            queue,
+            nextSeq: session.events.length === 0 ? 0 : Math.max(...session.events.map(entry => entry.event.seq)) + 1,
+            turn: Math.max(0, ...session.events.map(entry => (isRecord(entry.event.data) && typeof entry.event.data.turn === 'number' ? entry.event.data.turn : 0))),
+            stepOpen: false,
+            streamActive: false,
+            assistantStreamRevision: 0,
+            accumulatedText: '',
+            activeToolCalls: new Set(),
+        };
+        this.follows.add(follow);
+        const stream = await this.client.openStream(session.acpSessionId, frame => this.acceptAcpFrame(follow, frame), () => this.closeFollowAfterRemoteStreamClosed(follow));
+        follow.close = async () => {
+            controller.abort();
+            await stream.close();
+        };
+    }
+    acceptAcpFrame(follow, frame) {
+        const method = frame.frame.method;
+        const params = record(frame.frame.params);
+        if (method === 'session/update') {
+            this.acceptSessionUpdate(follow, params);
+            return;
+        }
+        if (method === 'session/request_permission' || method === 'cursor/ask_question' || method === 'cursor/create_plan') {
+            this.acceptApproval(follow, params, method);
+        }
+    }
+    acceptSessionUpdate(follow, params) {
+        const update = isRecord(params.update) ? params.update : params;
+        const kind = string(update.sessionUpdate) ?? string(update.type);
+        const session = this.sessions.get(follow.sessionId);
+        if (kind === 'model_selection' && isRecord(update.selected)
+            && update.selected.provider === this.backend && typeof update.selected.model === 'string') {
+            this.selectedModels.set(follow.sessionId, update.selected);
+            this.publishProjection(follow.sessionId, 'modelSelection', this.modelSelectionProjection(follow.sessionId), this.nextProjectionSeq());
+            return;
+        }
+        if (kind === 'agent_message_chunk' || kind === 'agent_message') {
+            const text = extractText(update);
+            if (text === undefined || text.length === 0)
+                return;
+            this.appendAssistantDelta(follow, text);
+            return;
+        }
+        if (kind === 'tool_call' || kind === 'tool_call_update') {
+            const toolName = string(update.title) ?? string(update.toolName) ?? string(update.name) ?? 'tool';
+            const status = string(update.status);
+            const callId = string(update.toolCallId) ?? string(update.callId) ?? toolName;
+            const terminal = status === 'completed' || status === 'failed';
+            if (kind === 'tool_call_update' && !terminal)
+                return;
+            if (kind === 'tool_call' && follow.activeToolCalls.has(callId))
+                return;
+            this.pushEvent(follow, 'tool/call', {
+                turn: follow.turn,
+                step: 1,
+                callId,
+                name: toolName,
+                arguments: typeof update.parameters === 'object' && update.parameters !== null
+                    ? JSON.stringify(update.parameters)
+                    : typeof update.rawInput === 'object' && update.rawInput !== null
+                        ? JSON.stringify(update.rawInput)
+                        : '{}',
+                toolCallId: callId,
+                toolName,
+                status: status === 'completed' ? 'finished' : status === 'failed' ? 'failed' : 'running',
+            });
+            if (terminal)
+                follow.activeToolCalls.delete(callId);
+            else
+                follow.activeToolCalls.add(callId);
+            if (session !== undefined)
+                session.updatedAt = Date.now();
+            return;
+        }
+        if (kind === 'agent_thought_chunk') {
+            const text = extractText(update);
+            if (text === undefined || text.length === 0)
+                return;
+            this.appendReasoningDelta(follow, text);
+            return;
+        }
+        if (kind === 'prompt_completed' || kind === 'prompt_failed') {
+            const hasLiveContent = follow.stepOpen || follow.streamActive;
+            if (!hasLiveContent && Array.isArray(update.catchUp)) {
+                for (const item of update.catchUp) {
+                    if (!isRecord(item) || typeof item.method !== 'string')
+                        continue;
+                    const params = isRecord(item.params) ? item.params : {};
+                    if (item.method === 'session/update')
+                        this.acceptSessionUpdate(follow, params);
+                }
+            }
+            if (session !== undefined) {
+                session.running = false;
+                session.updatedAt = Date.now();
+                this.emitRemoteEvent('api-session/status', [follow.sessionId, false]);
+                if (kind === 'prompt_completed')
+                    void this.refreshSessionTitle(session);
+            }
+            this.closeFollowAfterRemoteStreamClosed(follow);
+        }
+    }
+    acceptApproval(follow, params, method) {
+        const requestHandle = string(params.requestHandle);
+        if (requestHandle === undefined)
+            return;
+        this.pendingApprovals.set(requestHandle, { requestHandle, sessionId: follow.sessionId });
+        const toolName = method === 'cursor/create_plan'
+            ? (string(params.name) ?? 'plan')
+            : method === 'cursor/ask_question'
+                ? (string(params.title) ?? 'question')
+                : (string(params.toolName) ?? 'permission');
+        const reason = method === 'cursor/create_plan'
+            ? string(params.overview) ?? string(params.plan)
+            : method === 'cursor/ask_question'
+                ? summarizeQuestions(params)
+                : string(params.reason);
+        this.emitApproval({
+            eventId: requestHandle,
+            agentId: follow.sessionId,
+            request: {
+                toolName,
+                ...(reason === undefined ? {} : { reason }),
+            },
+        });
+    }
+    pushAssistantChunk(follow, chunk) {
+        let attempt = follow.assistantAttempt;
+        if (attempt === undefined) {
+            attempt = {
+                attemptId: `cursor-attempt:${follow.turn}:${follow.nextSeq}`,
+                startedAfterSeq: follow.nextSeq - 1,
+                nextIndex: 0,
+                stream: [],
+            };
+            follow.assistantAttempt = attempt;
+            follow.assistantStreamRevision += 1;
+            follow.queue.push({
+                type: 'assistant-stream',
+                frame: {
+                    type: 'start',
+                    attemptId: attempt.attemptId,
+                    revision: follow.assistantStreamRevision,
+                    startedAfterSeq: attempt.startedAfterSeq,
+                    turn: follow.turn,
+                    step: 1,
+                },
+            });
+        }
+        const time = Date.now();
+        const index = attempt.nextIndex++;
+        // Durable streams use AssistantStreamRecord, unlike the timed chunks in
+        // the live feed. Without this discriminator the native reader treats a
+        // raw chunk as a packed run and throws while settling the conversation.
+        attempt.stream.push({ type: 'chunk', time, chunk });
+        follow.assistantStreamRevision += 1;
+        follow.queue.push({
+            type: 'assistant-stream',
+            frame: {
+                type: 'chunk',
+                attemptId: attempt.attemptId,
+                revision: follow.assistantStreamRevision,
+                index,
+                time,
+                chunk,
+            },
+        });
+    }
+    endAssistantAttempt(follow, outcome) {
+        const attempt = follow.assistantAttempt;
+        if (attempt === undefined)
+            return;
+        follow.assistantAttempt = undefined;
+        follow.assistantStreamRevision += 1;
+        follow.queue.push({
+            type: 'assistant-stream',
+            frame: {
+                type: 'end',
+                attemptId: attempt.attemptId,
+                revision: follow.assistantStreamRevision,
+                index: attempt.nextIndex,
+                outcome,
+            },
+        });
+    }
+    appendAssistantDelta(follow, delta) {
+        if (!follow.stepOpen) {
+            follow.turn += 1;
+            follow.stepOpen = true;
+            this.pushEvent(follow, 'turn/start', { turn: follow.turn });
+            this.pushEvent(follow, 'step/start', { turn: follow.turn, step: 1 });
+        }
+        if (follow.blockIndex === undefined) {
+            follow.blockIndex = (follow.reasoningBlockIndex ?? -1) + 1;
+            follow.streamActive = true;
+            this.pushAssistantChunk(follow, { type: 'block-start', index: follow.blockIndex, blockType: 'text' });
+        }
+        follow.accumulatedText += delta;
+        this.pushAssistantChunk(follow, { type: 'text-delta', index: follow.blockIndex, text: delta });
+    }
+    appendReasoningDelta(follow, delta) {
+        if (!follow.stepOpen) {
+            follow.turn += 1;
+            follow.stepOpen = true;
+            this.pushEvent(follow, 'turn/start', { turn: follow.turn });
+            this.pushEvent(follow, 'step/start', { turn: follow.turn, step: 1 });
+        }
+        if (follow.reasoningBlockIndex === undefined) {
+            follow.reasoningBlockIndex = (follow.blockIndex ?? -1) + 1;
+            follow.streamActive = true;
+            this.pushAssistantChunk(follow, { type: 'block-start', index: follow.reasoningBlockIndex, blockType: 'reasoning' });
+        }
+        this.pushAssistantChunk(follow, { type: 'reasoning-delta', index: follow.reasoningBlockIndex, text: delta });
+    }
+    closeFollowAfterRemoteStreamClosed(follow) {
+        if (follow.streamActive) {
+            if (follow.reasoningBlockIndex !== undefined) {
+                this.pushAssistantChunk(follow, {
+                    type: 'block-end',
+                    index: follow.reasoningBlockIndex,
+                    block: { type: 'reasoning', text: '' },
+                });
+                follow.reasoningBlockIndex = undefined;
+            }
+            if (follow.blockIndex !== undefined) {
+                const fullText = follow.accumulatedText;
+                this.pushAssistantChunk(follow, {
+                    type: 'block-end',
+                    index: follow.blockIndex,
+                    block: { type: 'text', text: fullText },
+                });
+            }
+            this.pushAssistantChunk(follow, {
+                type: 'finish',
+                reason: { kind: 'stop' },
+            });
+            const fullText = follow.accumulatedText;
+            const selection = this.modelSelection(follow.sessionId);
+            const stream = follow.assistantAttempt?.stream ?? [];
+            const assistantMessageSeq = this.pushEvent(follow, 'assistant/message', {
+                turn: follow.turn,
+                step: 1,
+                message: {
+                    id: `${follow.sessionId}:${follow.turn}`,
+                    role: 'assistant',
+                    content: [{ type: 'text', text: fullText }],
+                    source: { kind: 'model', provider: selection.provider, model: selection.model },
+                },
+                stream,
+            });
+            this.endAssistantAttempt(follow, {
+                kind: 'committed',
+                eventType: 'assistant/message',
+                seq: assistantMessageSeq,
+            });
+            this.pushEvent(follow, 'step/end', { turn: follow.turn, step: 1 });
+            this.pushEvent(follow, 'turn/end', { turn: follow.turn, reason: { kind: 'completed' } });
+        }
+        else if (follow.stepOpen) {
+            this.pushEvent(follow, 'step/end', { turn: follow.turn, step: 1 });
+            this.pushEvent(follow, 'turn/end', { turn: follow.turn, reason: { kind: 'completed' } });
+        }
+        follow.streamActive = false;
+        follow.stepOpen = false;
+        follow.blockIndex = undefined;
+        follow.reasoningBlockIndex = undefined;
+        follow.accumulatedText = '';
+    }
+    pushEvent(follow, type, data) {
+        const session = this.sessions.get(follow.sessionId);
+        const seq = session !== undefined ? session.events.length : follow.nextSeq++;
+        const event = {
+            type,
+            seq,
+            time: Date.now(),
+            data,
+            ...(isSurfaceEvent(type) ? { surfaceOp: 'append' } : {}),
+        };
+        if (session !== undefined) {
+            session.events.push({ type: 'event', event });
+        }
+        for (const f of this.follows) {
+            if (f.sessionId === follow.sessionId) {
+                f.queue.push({ type: 'event', event });
+                f.nextSeq = seq + 1;
+            }
+        }
+        this.broadcastRcMux({
+            type: 'session/event',
+            sessionId: follow.sessionId,
+            event,
+        });
+        return seq;
+    }
+    registerSession(acpSessionId, cwd, title, createdAt = Date.now(), updatedAt = Date.now(), blank = true) {
+        const session = {
+            sessionId: `${this.backend === 'antigravity' ? ACP_SESSION_PREFIX : CURSOR_SESSION_PREFIX}${acpSessionId}`,
+            acpSessionId,
+            cwd,
+            ...(title === undefined ? {} : { title }),
+            blank,
+            running: false,
+            createdAt,
+            updatedAt,
+            events: [],
+        };
+        this.sessions.set(session.sessionId, session);
+        return session;
+    }
+    applyDiscoveredTitle(session, title) {
+        const next = title.trim();
+        if (this.closed || session.titleOverridden || !next || next === 'Untitled Session' || next === session.title)
+            return;
+        session.title = next;
+        this.publishProjection(session.sessionId, 'title', next);
+    }
+    async refreshSessionTitle(session) {
+        if (this.backend !== 'antigravity' || this.closed || session.titleOverridden || this.client.listSessions === undefined)
+            return;
+        try {
+            const items = await this.client.listSessions(session.cwd, this.backend, 30);
+            const current = items.find(item => item.conversationId === session.acpSessionId);
+            if (current !== undefined && this.sessions.get(session.sessionId) === session)
+                this.applyDiscoveredTitle(session, current.title);
+        }
+        catch {
+            // Title discovery must not delay or fail an already completed turn.
+        }
+    }
+    async discoverAndAttachSessions(workspace) {
+        if (this.backend !== 'antigravity')
+            return;
+        try {
+            let discovered = [];
+            if (this.client.listSessions !== undefined) {
+                try {
+                    discovered = await this.client.listSessions(workspace.path, this.backend, 30);
+                }
+                catch {
+                    // Keep the projection empty until remote history is available.
+                }
+            }
+            for (const item of discovered) {
+                const sessionId = `${ACP_SESSION_PREFIX}${item.conversationId}`;
+                if (!this.sessions.has(sessionId)) {
+                    this.registerSession(item.conversationId, workspace.path, item.title, item.createdAt, item.updatedAt, false);
+                }
+                const existing = this.sessions.get(sessionId);
+                if (existing !== undefined)
+                    this.applyDiscoveredTitle(existing, item.title);
+                if (!workspace.sessionIds.includes(sessionId)) {
+                    workspace.sessionIds.push(sessionId);
+                }
+            }
+            workspace.sessionCount = workspace.sessionIds.length;
+            workspace.updatedAt = new Date().toISOString();
+        }
+        catch {
+            // 容错降级
+        }
+    }
+    attachSessionToWorkspace(cwd, sessionId) {
+        const workspace = [...this.workspaceById.values()].find(item => item.path === cwd)
+            ?? createAcpWorkspaceView(cwd, this.backend);
+        const sessionIds = [sessionId, ...workspace.sessionIds.filter(id => id !== sessionId)];
+        const next = {
+            ...workspace,
+            sessionIds,
+            sessionCount: sessionIds.length,
+            updatedAt: new Date().toISOString(),
+        };
+        this.workspaceById.set(next.workspaceId, next);
+        if (this.selectedWorkspaceId === undefined)
+            this.selectedWorkspaceId = next.workspaceId;
+    }
+    async ensureInitialSession(workspace) {
+        const cwd = workspace.path;
+        const created = await this.client.createSession(cwd, 'agent', this.backend);
+        const sessionId = created.sessionId;
+        const title = this.backend === 'antigravity' ? 'Antigravity' : workspace.title;
+        const session = this.registerSession(sessionId, cwd, title);
+        this.attachSessionToWorkspace(cwd, session.sessionId);
+        this.emitRemoteEvent('api-session/added', [this.sessionSummary(session, 0)]);
+        this.publishWorkspaceBaseline();
+        return session;
+    }
+    async handleSessionList() {
+        for (const workspace of this.workspaceById.values()) {
+            await this.discoverAndAttachSessions(workspace);
+            if (workspace.sessionIds.length === 0) {
+                await this.ensureInitialSession(workspace);
+            }
+        }
+        return this.sessionSummaries();
+    }
+    sessionSummaries() {
+        const selected = this.selectedWorkspaceId === undefined
+            ? undefined
+            : this.workspaceById.get(this.selectedWorkspaceId);
+        const allowed = new Set(selected?.sessionIds ?? [...this.sessions.keys()]);
+        return [...this.sessions.values()]
+            .filter(session => allowed.has(session.sessionId))
+            .map(session => this.sessionSummary(session, 0));
+    }
+    sessionSummary(session, asOfSeq) {
+        return {
+            sessionId: session.sessionId,
+            agentAvailable: true,
+            running: session.running,
+            blank: session.blank,
+            cwd: session.cwd,
+            updatedAt: session.updatedAt,
+            projections: {
+                kind: 'sequenced',
+                asOfSeq,
+                values: {
+                    title: session.title ?? (this.backend === 'antigravity' ? 'Antigravity' : 'Cursor'),
+                    sessionListMetadata: { blank: session.blank, lastPromptAt: null },
+                    modelSelection: this.modelSelectionProjection(session.sessionId),
+                    imageLimits: acpImageLimits(this.backend),
+                },
+            },
+        };
+    }
+    modelSelection(sessionId) {
+        return this.selectedModels.get(sessionId) ?? modelCatalog(this.backend).default;
+    }
+    modelSelectionProjection(sessionId) {
+        const selection = this.modelSelection(sessionId);
+        return { lastUsed: selection, next: selection };
+    }
+    async hostSessionModels(sessionId) {
+        if (this.backend !== 'antigravity' || !this.client.sessionModels)
+            return { current: { provider: this.backend, model: 'host-settings' }, routable: true, groups: [], failures: [] };
+        const models = await this.client.sessionModels(nativeAcpId(sessionId, this.backend), 'antigravity');
+        this.selectedModels.set(sessionId, models.current);
+        return models;
+    }
+    async selectModel(request) {
+        const sessionId = extractSessionId(request);
+        nativeAcpId(sessionId, this.backend);
+        const provider = requiredString(request.provider, 'provider');
+        const model = requiredString(request.model, 'model');
+        const reasoningEffort = string(request.reasoningEffort);
+        const catalog = this.backend === 'antigravity' ? await this.hostSessionModels(sessionId) : modelCatalog(this.backend);
+        const group = catalog.groups.find(g => g.id === provider);
+        const targetModel = group?.models.find(m => m.id === model);
+        if (group === undefined || targetModel === undefined) {
+            return failure('model-unavailable', `The selected ${this.backend} model is unavailable on this Host.`);
+        }
+        const supportedEfforts = targetModel.reasoning?.efforts.map(effort => effort.id) ?? [];
+        if (reasoningEffort !== undefined && !supportedEfforts.includes(reasoningEffort)) {
+            return failure('model-unavailable', `The selected reasoning effort is unavailable for this ${this.backend} model.`);
+        }
+        const selected = {
+            provider,
+            model,
+            ...(reasoningEffort === undefined ? {} : { reasoningEffort }),
+        };
+        if (this.backend === 'antigravity') {
+            if (!this.client.selectModel)
+                return failure('model-unavailable', 'The Host does not support ACP model selection.');
+            const confirmed = await this.client.selectModel(nativeAcpId(sessionId, this.backend), 'antigravity', selected);
+            this.selectedModels.set(sessionId, confirmed);
+        }
+        else
+            return failure('model-unavailable', 'Cursor model selection follows Host settings.');
+        const seq = this.nextProjectionSeq();
+        this.publishProjection(sessionId, 'modelSelection', this.modelSelectionProjection(sessionId), seq);
+        return success({ selected: this.modelSelection(sessionId) });
+    }
+    publishWorkspaceBaseline() {
+        for (const queue of this.workspaceStreams) {
+            for (const workspace of this.visibleWorkspaces()) {
+                queue.push({ type: 'upsert', workspace: nativeWorkspace(workspace) });
+            }
+            queue.push({ type: 'archived', archivedSessionIds: [] });
+        }
+    }
+    publishProjection(sessionId, key, value, seq = this.nextProjectionSeq()) {
+        for (const queue of this.controlStreams) {
+            queue.push({ type: 'projection', sessionId, key, value, asOfSeq: seq, seq });
+        }
+        this.broadcastRcMux({ type: 'session/projection', sessionId, key, value, seq });
+    }
+    emitRemoteEvent(event, args) {
+        for (const queue of this.eventStreams.values())
+            queue.push({ type: 'emit', event, args });
+        const sessionId = typeof args[0] === 'string' ? args[0] : undefined;
+        if (event === 'api-session/status' && sessionId !== undefined && typeof args[1] === 'boolean') {
+            this.broadcastRcHost({ type: 'host/session-status', sessionId, running: args[1] });
+        }
+        else if (event === 'api-session/removed' && sessionId !== undefined) {
+            this.broadcastRcHost({ type: 'host/session-removed', sessionId });
+        }
+        else if (event === 'api-session/added' && isRecord(args[0])) {
+            const summary = args[0];
+            this.broadcastRcHost({
+                type: 'host/session-added',
+                sessionId: summary.sessionId,
+                blank: summary.blank === true,
+                ...(typeof summary.cwd === 'string' ? { cwd: summary.cwd } : {}),
+            });
+        }
+    }
+    emitApproval(input) {
+        for (const queue of this.eventStreams.values())
+            queue.push({
+                type: 'waterfall',
+                event: 'approval/request',
+                eventId: input.eventId,
+                agentId: input.agentId,
+                request: input.request,
+            });
+        this.broadcastRcMux({
+            type: 'approval/requested',
+            sessionId: input.agentId,
+            approvalId: input.eventId,
+            toolName: string(input.request.toolName) ?? this.backendLabel(),
+            ...(typeof input.request.reason === 'string' ? { reason: input.request.reason } : {}),
+        }, input.eventId);
+    }
+    nextProjectionSeq() {
+        this.lastProjectionSeq += 1;
+        return this.lastProjectionSeq;
+    }
+    createApiProxy() {
+        const call = (endpoint) => async (request, signal) => {
+            const payload = endpoint === 'session.prompt' && isRecord(request.payload)
+                ? { ...request.payload, requestId: String(request.rpcId) }
+                : request.payload;
+            const result = await this.dispatch(rcEndpoint(endpoint), { args: { request: payload } }, signal ?? new AbortController().signal);
+            return {
+                rpcId: request.rpcId,
+                result: (result.ok
+                    ? success(result.value)
+                    : failure(result.error.code, result.error.message, result.error.details)),
+            };
+        };
+        return {
+            sessions: {
+                list: call('session.list'),
+                search: call('session.search'),
+                create: call('session.create'),
+                history: call('session.history'),
+                models: call('session.models'),
+                selectModel: call('session.selectModel'),
+                rename: call('session.rename'),
+                fork: call('session.fork'),
+                prompt: call('session.prompt'),
+                attachment: call('session.attachment'),
+                updateQueue: call('session.updateQueue'),
+                cancel: call('session.cancel'),
+            },
+            workspace: {
+                list: call('workspace.list'),
+                create: call('workspace.create'),
+                rename: call('workspace.rename'),
+                delete: call('workspace.delete'),
+                insertBefore: call('workspace.insertBefore'),
+                insertSessionBefore: call('workspace.insertSessionBefore'),
+                archiveSession: call('workspace.archiveSession'),
+            },
+            subagents: {},
+            host: {
+                describe: call('host.describe'),
+                listDirectory: call('host.listDirectory'),
+            },
+            skills: { list: call('skills.list') },
+            agentPresets: {},
+            goals: {},
+            settings: {},
+            credentials: {},
+            llm: {},
+            events: {
+                mux: ((request, signal) => this.rcMux(request, signal)),
+                host: ((request, signal) => this.rcHost(request, signal)),
+            },
+            downloads: {},
+            respond: async (message) => {
+                const pending = this.pendingApprovals.get(String(message.rpcId))
+                    ?? [...this.pendingApprovals.values()].find(item => item.requestHandle === String(message.rpcId));
+                if (pending === undefined)
+                    return { accepted: false, reason: 'not-pending' };
+                const result = message.result;
+                const outcome = result.ok ? result.value : undefined;
+                const decision = outcome === 'allowed-once' ? 'allow-once' : outcome === 'cancelled' ? 'cancel' : 'reject-once';
+                await this.client.respond(pending.requestHandle, decision);
+                this.pendingApprovals.delete(pending.requestHandle);
+                return { accepted: true };
+            },
+        };
+    }
+    async *rcMux(request, signal) {
+        const queue = new AsyncValueQueue(signal);
+        this.rcMuxStreams.add(queue);
+        for (const session of this.sessions.values()) {
+            queue.push({
+                rpcId: `${String(request.rpcId)}:${session.sessionId}:subscribed`,
+                payload: { type: 'session/subscribed', sessionId: session.sessionId, lastSeq: -1 },
+            });
+        }
+        try {
+            yield* queue;
+        }
+        finally {
+            this.rcMuxStreams.delete(queue);
+            queue.close();
+        }
+    }
+    async *rcHost(_request, signal) {
+        const queue = new AsyncValueQueue(signal);
+        this.rcHostStreams.add(queue);
+        try {
+            yield* queue;
+        }
+        finally {
+            this.rcHostStreams.delete(queue);
+            queue.close();
+        }
+    }
+    broadcastRcMux(payload, rpcId = `cursor-mux:${Date.now()}:${Math.random()}`) {
+        for (const queue of this.rcMuxStreams)
+            queue.push({ rpcId, payload });
+    }
+    broadcastRcHost(payload) {
+        const frame = { rpcId: `cursor-host:${Date.now()}:${Math.random()}`, payload };
+        for (const queue of this.rcHostStreams)
+            queue.push(frame);
+    }
+}
+function recreateWorkspaceFromId(workspaceId, backend) {
+    const prefix = backend === 'antigravity' ? AGY_WORKSPACE_PREFIX : CURSOR_WORKSPACE_PREFIX;
+    if (!workspaceId.startsWith(prefix))
+        return undefined;
+    try {
+        const path = decodeURIComponent(workspaceId.slice(prefix.length));
+        if (path.length > 0)
+            return createAcpWorkspaceView(path, backend);
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+function nativeWorkspace(view) {
+    return {
+        workspaceId: view.workspaceId,
+        path: view.path,
+        title: view.title,
+        sessionIds: view.sessionIds,
+        createdAt: view.createdAt,
+        updatedAt: view.updatedAt,
+    };
+}
+const CURSOR_MODELS = [
+    { id: 'auto', name: 'Auto' },
+    { id: 'claude-3.7-sonnet', name: 'Claude 3.7 Sonnet' },
+    { id: 'claude-3.5-sonnet', name: 'Claude 3.5 Sonnet' },
+    { id: 'gpt-4o', name: 'GPT-4o' },
+    { id: 'o3-mini', name: 'o3-mini' },
+    { id: 'deepseek-r1', name: 'DeepSeek R1' },
+];
+export function modelCatalog(backend = 'cursor') {
+    const provider = backend === 'antigravity' ? 'antigravity' : CURSOR_PROVIDER;
+    const name = backend === 'antigravity' ? 'Antigravity' : 'Cursor';
+    const models = backend === 'antigravity' ? [] : CURSOR_MODELS;
+    const defaultModel = models[0]?.id ?? 'host-settings';
+    return {
+        default: { provider, model: defaultModel },
+        routableProviders: [provider],
+        groups: [{
+                id: provider,
+                name,
+                models,
+            }],
+        failures: [],
+    };
+}
+function extractPromptText(content) {
+    const parts = content.flatMap(part => {
+        const item = record(part);
+        if (item.type === 'text' && typeof item.text === 'string')
+            return [item.text];
+        return [];
+    });
+    const text = parts.join('');
+    return text.length === 0 ? undefined : text;
+}
+function extractText(update) {
+    const content = update.content;
+    if (typeof content === 'string')
+        return content;
+    if (isRecord(content) && typeof content.text === 'string')
+        return content.text;
+    if (Array.isArray(content)) {
+        const parts = content
+            .map(part => (isRecord(part) && typeof part.text === 'string' ? part.text : undefined))
+            .filter((part) => part !== undefined);
+        return parts.length === 0 ? undefined : parts.join('');
+    }
+    return typeof update.text === 'string' ? update.text : undefined;
+}
+function summarizeQuestions(params) {
+    if (!Array.isArray(params.questions))
+        return undefined;
+    const lines = params.questions
+        .map(question => (isRecord(question) ? string(question.prompt) : undefined))
+        .filter((line) => line !== undefined);
+    return lines.length === 0 ? undefined : lines.join('\n');
+}
+function sessionIdFromAddress(address) {
+    if (typeof address.sessionId === 'string' && address.sessionId.length > 0)
+        return address.sessionId;
+    if (typeof address.childSessionId === 'string' && address.childSessionId.length > 0)
+        return address.childSessionId;
+    if (address.kind === 'session' && typeof address.sessionId === 'string' && address.sessionId.length > 0) {
+        return address.sessionId;
+    }
+    throw new Error('The sessionId is required.');
+}
+function extractSessionId(request) {
+    if (typeof request.sessionId === 'string' && request.sessionId.length > 0)
+        return request.sessionId;
+    if (isRecord(request.address))
+        return sessionIdFromAddress(request.address);
+    throw new Error('The sessionId is required.');
+}
+function nativeAcpId(sessionId, backend) {
+    const prefix = backend === 'antigravity' ? ACP_SESSION_PREFIX : CURSOR_SESSION_PREFIX;
+    if (!sessionId.startsWith(prefix) || sessionId.length === prefix.length) {
+        throw new Error('The selected Session does not belong to the virtual harness.');
+    }
+    return sessionId.slice(prefix.length);
+}
+function isSurfaceEvent(type) {
+    return type === 'user/message' || type === 'assistant/message' || type === 'tool/result';
+}
+function carrierArgs(payload) {
+    return record(record(payload).args);
+}
+function requestArg(args) {
+    return record(args.request ?? args._request ?? args);
+}
+function rcEndpoint(endpoint) {
+    if (endpoint === 'workspace.list')
+        return 'workspace/list';
+    return endpoint.replace('.', '/');
+}
+function success(value) {
+    return { ok: true, value };
+}
+function failure(code, message, details = {}) {
+    return { ok: false, error: { code, message, details } };
+}
+function business(value) {
+    if (isRecord(value) && value.ok === false && isRecord(value.error)) {
+        return { ok: false, error: {
+                code: string(value.error.code) ?? 'internal',
+                message: string(value.error.message) ?? 'The virtual Harness request failed.',
+                details: isRecord(value.error.details) ? value.error.details : {},
+            } };
+    }
+    if (isRecord(value) && value.ok === true)
+        return { ok: true, value: value.value };
+    return { ok: true, value };
+}
+function fail(code, message, details = {}) {
+    return { ok: false, error: { code, message, details } };
+}
+function failFrom(error) {
+    const source = error instanceof Error ? error : new Error(String(error));
+    const code = 'code' in source && typeof source.code === 'string' ? source.code : 'internal';
+    return fail(code, source.message);
+}
+function record(value) {
+    return isRecord(value) ? value : {};
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function array(value) {
+    return Array.isArray(value) ? value : [];
+}
+function string(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function integer(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) ? value : undefined;
+}
+function optionalInteger(value) {
+    if (value === undefined)
+        return undefined;
+    const parsed = integer(value);
+    if (parsed === undefined)
+        throw new Error('The History cursor is invalid.');
+    return parsed;
+}
+function optionalPositiveInteger(value) {
+    const parsed = optionalInteger(value);
+    if (parsed !== undefined && parsed <= 0)
+        throw new Error('The History page size is invalid.');
+    return parsed;
+}
+function requiredString(value, field) {
+    if (typeof value !== 'string' || value.length === 0)
+        throw new Error(`The ${field} is required.`);
+    return value;
+}
+class AsyncValueQueue {
+    signal;
+    values = [];
+    waiters = [];
+    closed = false;
+    onAbort;
+    constructor(signal) {
+        this.signal = signal;
+        this.onAbort = () => this.close();
+        signal.addEventListener('abort', this.onAbort, { once: true });
+        if (signal.aborted)
+            this.close();
+    }
+    push(value) {
+        if (this.closed)
+            return;
+        const waiter = this.waiters.shift();
+        if (waiter === undefined)
+            this.values.push(value);
+        else
+            waiter({ done: false, value });
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.signal.removeEventListener('abort', this.onAbort);
+        for (const waiter of this.waiters.splice(0))
+            waiter({ done: true, value: undefined });
+    }
+    iterate(dispose) {
+        const queue = this;
+        return {
+            async *[Symbol.asyncIterator]() {
+                try {
+                    yield* queue;
+                }
+                finally {
+                    dispose();
+                    queue.close();
+                }
+            },
+        };
+    }
+    async *[Symbol.asyncIterator]() {
+        while (true) {
+            if (this.values.length > 0) {
+                yield this.values.shift();
+                continue;
+            }
+            if (this.closed)
+                return;
+            const next = await new Promise(resolve => this.waiters.push(resolve));
+            if (next.done)
+                return;
+            yield next.value;
+        }
+    }
+}
+//# sourceMappingURL=virtual-harness.js.map