ds-harness-remote 0.5.8 → 0.5.10

package/dist/acp/virtual-harness.js

@@ -1,53 +1,10 @@
-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 [];
-}
+import { ACP_TOOL_CALL_ENDPOINTS, ACP_TOOL_STREAM_ENDPOINTS } from '@dsh-remote/protocol';
+import { acpImageContent, acpImageLimits, parseAcpImage } from './image-content.js';
+import { createAcpWorkspaceView, modelCatalog, nativeWorkspace, recreateWorkspaceFromId } from './virtual-catalog.js';
+import { array, AsyncValueQueue, business, carrierArgs, extractPromptText, extractSessionId, fail, failFrom, failure, isRecord, nativeAcpId, optionalInteger, optionalPositiveInteger, record, requestArg, requiredString, sessionPrefix, string, success, } from './virtual-contract.js';
+import { AcpEventCarrier } from './virtual-event-carrier.js';
+import { AcpLiveProjection } from './virtual-live.js';
 /**
  * Browser-safe, in-memory Harness projection for the independent Agent ACP domain. Projects
  * cwd workspaces and ACP sessions onto the native DSH Workspace / Session /
@@ -58,6 +15,8 @@ export class AcpVirtualHarness {
     host;
     backend;
     hostCarrier;
+    live;
+    events;
     api;
     workspaceById = new Map();
     sessions = new Map();
@@ -68,12 +27,13 @@ export class AcpVirtualHarness {
     rcHostStreams = new Set();
     follows = new Set();
     pendingApprovals = new Map();
+    pendingHistory = new Map();
     selectedWorkspaceId;
     selectedModels = new Map();
     lastProjectionSeq = 0;
     imageAttachments = new Map();
     closed = false;
-    constructor(client, host, backend = 'cursor', 
+    constructor(client, host, backend = "cursor", 
     /**
      * Host gateway used for endpoints this virtual Harness does not project
      * (settings, plugins, models, credentials, …). A real Harness workspace
@@ -85,16 +45,52 @@ export class AcpVirtualHarness {
         this.host = host;
         this.backend = backend;
         this.hostCarrier = hostCarrier;
-        this.api = this.createApiProxy();
+        const owner = this;
+        this.live = new AcpLiveProjection({
+            ensureSessionRegistered: (...args) => owner.ensureSessionRegistered(...args),
+            get sessions() { return owner.sessions; },
+            hydrateSession: (...args) => owner.hydrateSession(...args),
+            historyPage: (...args) => owner.historyPage(...args),
+            get follows() { return owner.follows; },
+            get backend() { return owner.backend; },
+            modelSelectionProjection: (...args) => owner.modelSelectionProjection(...args),
+            get client() { return owner.client; },
+            emitRemoteEvent: (...args) => owner.events.emitRemoteEvent(...args),
+            get selectedModels() { return owner.selectedModels; },
+            publishProjection: (...args) => owner.events.publishProjection(...args),
+            nextProjectionSeq: (...args) => owner.nextProjectionSeq(...args),
+            refreshSessionTitle: (...args) => owner.refreshSessionTitle(...args),
+            get pendingApprovals() { return owner.pendingApprovals; },
+            emitApproval: (...args) => owner.events.emitApproval(...args),
+            modelSelection: (...args) => owner.modelSelection(...args),
+            broadcastRcMux: (...args) => owner.events.broadcastRcMux(...args),
+        });
+        this.events = new AcpEventCarrier({
+            get workspaceStreams() { return owner.workspaceStreams; },
+            visibleWorkspaces: (...args) => owner.visibleWorkspaces(...args),
+            get controlStreams() { return owner.controlStreams; },
+            get eventStreams() { return owner.eventStreams; },
+            get selectedWorkspaceId() { return owner.selectedWorkspaceId; },
+            get workspaceById() { return owner.workspaceById; },
+            backendLabel: (...args) => owner.backendLabel(...args),
+            get pendingApprovals() { return owner.pendingApprovals; },
+            get client() { return owner.client; },
+            dispatch: (...args) => owner.dispatch(...args),
+            get rcMuxStreams() { return owner.rcMuxStreams; },
+            get sessions() { return owner.sessions; },
+            get rcHostStreams() { return owner.rcHostStreams; },
+            nextProjectionSeq: (...args) => owner.nextProjectionSeq(...args),
+        });
+        this.api = this.events.createApiProxy();
     }
-    static remote(core, host, backend = 'cursor', capabilities = [], hostCarrier) {
+    static remote(core, host, backend = "cursor", capabilities = [], hostCarrier) {
         return new AcpVirtualHarness(new AgentAcpClient(core, capabilities), host, backend, hostCarrier);
     }
     async workspaces() {
         return [...this.workspaceById.values()];
     }
     backendLabel() {
-        return this.backend === 'antigravity' ? 'Antigravity' : 'Cursor';
+        return this.backend === "pi" ? "PI" : this.backend === "opencode" ? "OpenCode" : this.backend === "antigravity" ? "Antigravity" : "Cursor";
     }
     async selectWorkspace(workspaceId) {
         const workspace = this.workspaceById.get(workspaceId) ?? recreateWorkspaceFromId(workspaceId, this.backend);
@@ -167,7 +163,7 @@ export class AcpVirtualHarness {
                 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 '$events/result': return business(await this.events.answerRemoteEvent(args, signal));
                 case 'workspace/list': return business(success({
                     items: this.visibleWorkspaces().map(nativeWorkspace),
                     archivedSessionIds: [],
@@ -182,6 +178,7 @@ export class AcpVirtualHarness {
                 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/projections': return business(await this.sessionProjections(requestArg(args)));
                 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.`));
@@ -194,7 +191,7 @@ export class AcpVirtualHarness {
                 case 'session/attachment': return business(await this.attachment(requestArg(args)));
                 case 'session/modelCatalog': {
                     const sessionId = await this.preferredSessionId();
-                    if (this.backend !== 'antigravity' || !sessionId)
+                    if (this.backend === 'cursor' || !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 }));
@@ -202,7 +199,7 @@ export class AcpVirtualHarness {
                 case 'session/models': {
                     const rawId = extractSessionId(requestArg(args));
                     nativeAcpId(rawId, this.backend);
-                    if (this.backend === 'antigravity')
+                    if (this.backend !== 'cursor')
                         return business(success(await this.hostSessionModels(rawId)));
                     const catalog = modelCatalog(this.backend);
                     return business(success({
@@ -243,15 +240,15 @@ export class AcpVirtualHarness {
             return queue.iterate(() => { void stream.close().catch(() => undefined); });
         }
         if (endpoint === 'workspace/follow')
-            return this.workspaceFollow(signal);
+            return this.events.workspaceFollow(signal);
         if (endpoint === 'session/control')
-            return this.sessionControl(signal);
+            return this.events.sessionControl(signal);
         if (endpoint === 'session/follow')
-            return this.sessionFollow(requestArg(args), signal);
+            return this.live.sessionFollow(requestArg(args), signal);
         if (endpoint === '$events')
-            return this.remoteEvents(signal);
+            return this.events.remoteEvents(signal);
         if (endpoint === 'job/list' || endpoint === 'job/follow')
-            return this.emptyJobStream(endpoint, signal);
+            return this.events.emptyJobStream(endpoint, signal);
         if (this.hostCarrier !== undefined)
             return this.hostCarrier.open(endpoint, payload, signal);
         throw Object.assign(new Error(`${this.backendLabel()} virtual Harness does not implement stream ${endpoint}.`), {
@@ -341,7 +338,7 @@ export class AcpVirtualHarness {
                 updatedAt: new Date().toISOString(),
             });
         }
-        this.emitRemoteEvent('api-session/removed', [sessionId]);
+        this.events.emitRemoteEvent('api-session/removed', [sessionId]);
         this.publishWorkspaceBaseline();
         return success({ archivedSessionIds: [sessionId] });
     }
@@ -357,26 +354,26 @@ export class AcpVirtualHarness {
             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}`)) {
+        if (this.backend !== 'cursor' && this.sessions.has(`${sessionPrefix(this.backend)}${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);
+        this.events.emitRemoteEvent('api-session/added', [this.sessionSummary(session, seq)]);
+        this.events.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);
+        if (this.backend !== 'cursor' && sessionId.startsWith(sessionPrefix(this.backend))) {
+            const acpSessionId = sessionId.slice(sessionPrefix(this.backend).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);
+            session = this.registerSession(acpSessionId, cwd, this.backendLabel(), Date.now(), Date.now(), false);
             if (workspace && !workspace.sessionIds.includes(sessionId)) {
                 workspace.sessionIds.unshift(sessionId);
                 workspace.sessionCount = workspace.sessionIds.length;
@@ -409,14 +406,14 @@ export class AcpVirtualHarness {
         const requestId = typeof request.requestId === 'string' && request.requestId.length > 0
             ? request.requestId
             : undefined;
-        await this.ensureFollow(session);
+        await this.live.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', {
+            this.live.pushEvent(follow, 'turn/start', { turn: follow.turn });
+            this.live.pushEvent(follow, 'step/start', { turn: follow.turn, step: 1 });
+            this.live.pushEvent(follow, 'user/message', {
                 id: `user:${Date.now()}`,
                 role: 'user',
                 content: [...(text ? [{ type: 'text', text }] : []), ...imageBlocks],
@@ -426,7 +423,7 @@ export class AcpVirtualHarness {
         session.blank = false;
         session.running = true;
         session.updatedAt = Date.now();
-        this.emitRemoteEvent('api-session/status', [sessionId, true]);
+        this.events.emitRemoteEvent('api-session/status', [sessionId, true]);
         await this.client.prompt(session.acpSessionId, text ?? '', signal, images, this.backend);
         return success({ accepted: true });
     }
@@ -439,10 +436,10 @@ export class AcpVirtualHarness {
         session.running = false;
         for (const follow of this.follows) {
             if (follow.sessionId === sessionId) {
-                this.closeFollowAfterRemoteStreamClosed(follow);
+                this.live.closeFollowAfterRemoteStreamClosed(follow, { kind: 'aborted', reason: { kind: 'user' } });
             }
         }
-        this.emitRemoteEvent('api-session/status', [sessionId, false]);
+        this.events.emitRemoteEvent('api-session/status', [sessionId, false]);
         return success({ accepted: true });
     }
     async renameSession(request) {
@@ -456,7 +453,7 @@ export class AcpVirtualHarness {
         session.title = title;
         session.titleOverridden = true;
         session.updatedAt = Date.now();
-        this.publishProjection(sessionId, 'title', title);
+        this.events.publishProjection(sessionId, 'title', title);
         return success({ sessionId });
     }
     cacheImageAttachments(sessionId, content) {
@@ -479,15 +476,35 @@ export class AcpVirtualHarness {
         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)
+        if (this.backend === 'cursor' || session.blank || session.events.length > 0)
             return;
+        if (this.backend !== 'pi')
+            return this.hydrateSessionOnce(session);
+        const pending = this.pendingHistory.get(session.sessionId);
+        if (pending)
+            return pending;
+        const read = this.hydrateSessionOnce(session);
+        this.pendingHistory.set(session.sessionId, read);
+        try {
+            await read;
+        }
+        finally {
+            if (this.pendingHistory.get(session.sessionId) === read)
+                this.pendingHistory.delete(session.sessionId);
+        }
+    }
+    async hydrateSessionOnce(session) {
         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.
+            catch (error) {
+                // A failed PI read is not a successful empty baseline; do not continue
+                // a restored conversation until its authoritative history is available.
+                if (this.backend === 'pi')
+                    throw error;
+                // Preserve legacy AGY history availability behavior.
             }
         }
         if (events.length > 0) {
@@ -514,7 +531,7 @@ export class AcpVirtualHarness {
             projections: {
                 asOfSeq: page.cursor,
                 values: {
-                    title: session.title ?? (this.backend === 'antigravity' ? 'Antigravity' : 'Cursor'),
+                    title: session.title ?? (this.backend === "pi" ? "PI" : this.backend === "opencode" ? "OpenCode" : this.backend === "antigravity" ? "Antigravity" : "Cursor"),
                     sessionListMetadata: { blank: session.blank && session.events.length === 0, lastPromptAt: null },
                     modelSelection: this.modelSelectionProjection(sessionId),
                     imageLimits: acpImageLimits(this.backend),
@@ -522,6 +539,14 @@ export class AcpVirtualHarness {
             },
         });
     }
+    async sessionProjections(request) {
+        const sessionId = extractSessionId(request);
+        const session = this.ensureSessionRegistered(sessionId) ?? this.sessions.get(sessionId);
+        if (session === undefined)
+            return success(null);
+        await this.hydrateSession(session);
+        return success(this.sessionSummary(session, session.events.at(-1)?.event.seq ?? -1).projections);
+    }
     async sessionPage(request) {
         const sessionId = extractSessionId(request);
         const session = this.ensureSessionRegistered(sessionId) ?? this.sessions.get(sessionId);
@@ -583,437 +608,9 @@ export class AcpVirtualHarness {
         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));
-    }
-    /**
-     * Background jobs belong to the Host Harness session, not to a backend-scoped
-     * virtual Workspace. The native session header mounts a job roster stream as
-     * soon as a Session opens, so answer it with an authoritative empty roster
-     * instead of a terminal `method-not-found` failure that tears the page down.
-     */
-    emptyJobStream(endpoint, signal) {
-        const queue = new AsyncValueQueue(signal);
-        if (endpoint === 'job/list')
-            queue.push({ type: 'rows', jobs: [] });
-        return queue.iterate(() => queue.close());
-    }
-    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}`,
+            sessionId: `${sessionPrefix(this.backend)}${acpSessionId}`,
             acpSessionId,
             cwd,
             ...(title === undefined ? {} : { title }),
@@ -1031,10 +628,10 @@ export class AcpVirtualHarness {
         if (this.closed || session.titleOverridden || !next || next === 'Untitled Session' || next === session.title)
             return;
         session.title = next;
-        this.publishProjection(session.sessionId, 'title', next);
+        this.events.publishProjection(session.sessionId, 'title', next);
     }
     async refreshSessionTitle(session) {
-        if (this.backend !== 'antigravity' || this.closed || session.titleOverridden || this.client.listSessions === undefined)
+        if (this.backend === 'cursor' || this.closed || session.titleOverridden || this.client.listSessions === undefined)
             return;
         try {
             const items = await this.client.listSessions(session.cwd, this.backend, 30);
@@ -1047,7 +644,7 @@ export class AcpVirtualHarness {
         }
     }
     async discoverAndAttachSessions(workspace) {
-        if (this.backend !== 'antigravity')
+        if (this.backend === 'cursor')
             return;
         try {
             let discovered = [];
@@ -1055,12 +652,14 @@ export class AcpVirtualHarness {
                 try {
                     discovered = await this.client.listSessions(workspace.path, this.backend, 30);
                 }
-                catch {
-                    // Keep the projection empty until remote history is available.
+                catch (error) {
+                    if (this.backend === 'pi')
+                        throw error;
+                    // Preserve legacy AGY catalog availability behavior.
                 }
             }
             for (const item of discovered) {
-                const sessionId = `${ACP_SESSION_PREFIX}${item.conversationId}`;
+                const sessionId = `${sessionPrefix(this.backend)}${item.conversationId}`;
                 if (!this.sessions.has(sessionId)) {
                     this.registerSession(item.conversationId, workspace.path, item.title, item.createdAt, item.updatedAt, false);
                 }
@@ -1074,8 +673,10 @@ export class AcpVirtualHarness {
             workspace.sessionCount = workspace.sessionIds.length;
             workspace.updatedAt = new Date().toISOString();
         }
-        catch {
-            // 容错降级
+        catch (error) {
+            if (this.backend === 'pi')
+                throw error;
+            // Preserve legacy AGY catalog availability behavior.
         }
     }
     attachSessionToWorkspace(cwd, sessionId) {
@@ -1096,10 +697,10 @@ export class AcpVirtualHarness {
         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 title = this.backend === 'antigravity' ? 'Antigravity' : this.backend === 'opencode' ? 'OpenCode' : workspace.title;
         const session = this.registerSession(sessionId, cwd, title);
         this.attachSessionToWorkspace(cwd, session.sessionId);
-        this.emitRemoteEvent('api-session/added', [this.sessionSummary(session, 0)]);
+        this.events.emitRemoteEvent('api-session/added', [this.sessionSummary(session, 0)]);
         this.publishWorkspaceBaseline();
         return session;
     }
@@ -1133,7 +734,7 @@ export class AcpVirtualHarness {
                 kind: 'sequenced',
                 asOfSeq,
                 values: {
-                    title: session.title ?? (this.backend === 'antigravity' ? 'Antigravity' : 'Cursor'),
+                    title: session.title ?? (this.backend === "pi" ? "PI" : this.backend === "opencode" ? "OpenCode" : this.backend === "antigravity" ? "Antigravity" : "Cursor"),
                     sessionListMetadata: { blank: session.blank, lastPromptAt: null },
                     modelSelection: this.modelSelectionProjection(session.sessionId),
                     imageLimits: acpImageLimits(this.backend),
@@ -1149,9 +750,9 @@ export class AcpVirtualHarness {
         return { lastUsed: selection, next: selection };
     }
     async hostSessionModels(sessionId) {
-        if (this.backend !== 'antigravity' || !this.client.sessionModels)
+        if (this.backend === 'cursor' || this.backend === 'opencode' || !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');
+        const models = await this.client.sessionModels(nativeAcpId(sessionId, this.backend), this.backend);
         this.selectedModels.set(sessionId, models.current);
         return models;
     }
@@ -1161,7 +762,7 @@ export class AcpVirtualHarness {
         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 catalog = this.backend !== 'cursor' ? 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) {
@@ -1176,16 +777,16 @@ export class AcpVirtualHarness {
             model,
             ...(reasoningEffort === undefined ? {} : { reasoningEffort }),
         };
-        if (this.backend === 'antigravity') {
+        if (this.backend !== 'cursor' && this.backend !== 'opencode') {
             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);
+            const confirmed = await this.client.selectModel(nativeAcpId(sessionId, this.backend), this.backend, selected);
             this.selectedModels.set(sessionId, confirmed);
         }
         else
-            return failure('model-unavailable', 'Cursor model selection follows Host settings.');
+            return failure('model-unavailable', `${this.backendLabel()} model selection follows Host settings.`);
         const seq = this.nextProjectionSeq();
-        this.publishProjection(sessionId, 'modelSelection', this.modelSelectionProjection(sessionId), seq);
+        this.events.publishProjection(sessionId, 'modelSelection', this.modelSelectionProjection(sessionId), seq);
         return success({ selected: this.modelSelection(sessionId) });
     }
     publishWorkspaceBaseline() {
@@ -1196,393 +797,10 @@ export class AcpVirtualHarness {
             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;
-        }
-    }
 }
+export { acpCwdWorkspaceId, createAcpWorkspaceView, discoverAcpVirtualWorkspaces, modelCatalog } from './virtual-catalog.js';
 //# sourceMappingURL=virtual-harness.js.map