@xenosystem/agent-interface-ui 0.1.3

package/dist/adapters/agentHostPlatformBridge.js

@@ -0,0 +1,1244 @@
+/**
+ * Adapts the versioned Agent host client to the temporary legacy-shaped UI
+ * bridge. Only host-backed features are exposed; unsupported Hub-only
+ * namespaces remain absent so the shared UI renders an honest degraded state.
+ */
+export function createAgentHostPlatformBridge(client, options = {}) {
+    const runtimeListeners = new Set();
+    const errorListeners = new Set();
+    const chooseDirectoryListeners = new Set();
+    const workspacePlacementListeners = new Set();
+    const permissionListeners = new Set();
+    const askUserListeners = new Set();
+    const taskListeners = new Set();
+    const terminalDataListeners = new Set();
+    const terminalExitListeners = new Set();
+    const ptyDataListeners = new Set();
+    const ptyExitListeners = new Set();
+    const runtimeSubscriptions = new Map();
+    const chooseDirectorySubscriptions = new Map();
+    const workspacePlacementSubscriptions = new Map();
+    const sessionListeners = new Set();
+    const fleetListeners = new Set();
+    const observationListeners = new Set();
+    const catalogListeners = new Set();
+    const activeConversations = new Map();
+    const pendingCancellations = new Set();
+    let subscriptionSequence = 0;
+    const unsubscribe = client.subscribe((event) => {
+        routeHostEvent(event, {
+            runtimeListeners,
+            errorListeners,
+            chooseDirectoryListeners,
+            workspacePlacementListeners,
+            permissionListeners,
+            askUserListeners,
+            taskListeners,
+            runtimeSubscriptions,
+            chooseDirectorySubscriptions,
+            workspacePlacementSubscriptions,
+            activeConversations,
+            terminalDataListeners,
+            terminalExitListeners,
+            ptyDataListeners,
+            ptyExitListeners,
+            sessionListeners,
+            fleetListeners,
+            observationListeners,
+            catalogListeners,
+            clientInstanceId: client.instanceId,
+        });
+    });
+    const unsupported = (feature) => ({ success: false, error: `${feature} is not available on this host yet.` });
+    const agent = {
+        run: async (params) => runHostPrompt(client, activeConversations, pendingCancellations, params),
+        cancel: async (requestId) => cancelByRequestId(client, activeConversations, pendingCancellations, requestId),
+        // The legacy per-chunk callback stream (onTextChunk/onToolStart/onToolEnd/onDone)
+        // is deliberately ABSENT here: this host publishes the same information as native
+        // `runtime.event.appended` envelopes through `onRuntimeEvent`. Registering an
+        // inert no-op would make the missing stream indistinguishable from a working one,
+        // so callers must feature-detect these methods instead.
+        onRuntimeEvent: (callback) => { runtimeListeners.add(callback); },
+        offRuntimeEvent: () => { runtimeListeners.clear(); },
+        onTaskEvent: (callback) => { taskListeners.add(callback); },
+        offTaskEvent: () => { taskListeners.clear(); },
+        onError: (callback) => { errorListeners.add(callback); },
+        offError: () => { errorListeners.clear(); },
+        onPermissionRequest: (callback) => { permissionListeners.add(callback); },
+        offPermissionRequest: () => { permissionListeners.clear(); },
+        onAskUserRequest: (callback) => { askUserListeners.add(callback); },
+        offAskUserRequest: () => { askUserListeners.clear(); },
+        onChooseDirectoryRequest: (callback) => { chooseDirectoryListeners.add(callback); },
+        offChooseDirectoryRequest: () => { chooseDirectoryListeners.clear(); },
+        subscribeChooseDirectoryRequested: (callback) => (addSubscription(chooseDirectorySubscriptions, callback, () => ++subscriptionSequence, 'choose-directory')),
+        unsubscribeChooseDirectoryRequested: (id) => chooseDirectorySubscriptions.delete(id),
+        onWorkspacePlacementRequest: (callback) => {
+            workspacePlacementListeners.add(callback);
+        },
+        offWorkspacePlacementRequest: () => { workspacePlacementListeners.clear(); },
+        subscribeWorkspacePlacementRequested: (callback) => (addSubscription(workspacePlacementSubscriptions, callback, () => ++subscriptionSequence, 'workspace-placement')),
+        unsubscribeWorkspacePlacementRequested: (id) => workspacePlacementSubscriptions.delete(id),
+        grantAccess: async (input) => client.answerPermission({
+            permissionId: input.permissionId,
+            granted: true,
+            directory: input.directory,
+            ...(input.selectedOptionId ? { selectedOptionId: input.selectedOptionId } : {}),
+        }),
+        steerTurn: async (input) => {
+            const result = await client.steerTurn(input);
+            // A provider that cannot be steered refuses BY NAME. The caller leaves the
+            // message queued rather than pretending it was delivered.
+            return result.success
+                ? { success: true }
+                : { success: false, error: result.safeError };
+        },
+        resumeTurn: async (input) => {
+            const result = await client.resumeTurn(input);
+            return result.success
+                ? { success: true }
+                : { success: false, error: result.safeError };
+        },
+        /**
+         * 🔴 The queue, bound. Both halves, because a read with no undo is
+         * a list of things a person can watch and not change.
+         *
+         * `drop` goes through the client wrapper rather than the transport: its
+         * request carries a host-minted command context, and a caller must never
+         * forge one.
+         */
+        /**
+         * 🔴 Coordination §6's human half, bound. Both calls, because a list of
+         * withheld messages with no way to approve one is a list of things a
+         * person can read and not act on.
+         *
+         * `release` goes through the client wrapper: its request carries a
+         * host-minted command context, and approving another agent's message is
+         * exactly the act that should be attributable.
+         */
+        listHeldMessages: (input) => client.listHeldMessages(input),
+        releaseHeldMessage: (input) => client.releaseHeldMessage(input),
+        setInboundPolicy: (input) => client.setInboundPolicy(input),
+        listQueuedInstructions: (input) => client.listQueuedInstructions(input),
+        dropQueuedInstruction: async (input) => {
+            const result = await client.dropQueuedInstruction(input);
+            return result.success
+                ? { success: true }
+                : { success: false, safeError: result.safeError };
+        },
+        listPermissionRules: async () => client.listPermissionRules(),
+        revokePermissionRule: async (input) => client.revokePermissionRule(input.ruleId),
+        denyAccess: async (input) => client.answerPermission({
+            permissionId: input.permissionId,
+            granted: false,
+            // Present only for "never allow this". The host verifies the id was
+            // offered AND that its kind agrees with granted:false before honouring it.
+            ...(input.selectedOptionId ? { selectedOptionId: input.selectedOptionId } : {}),
+        }),
+        answerAskUser: async (input) => (client.answerAskUser(input)),
+        answerChooseDirectory: async (input) => (client.answerChooseDirectory(input)),
+        answerWorkspacePlacement: async (input) => (client.answerWorkspacePlacement(input)),
+        listSdkSessions: async (input = {}) => (client.listSdkSessions(input)),
+        showSdkSession: async (input) => (client.showSdkSession(input)),
+        attachSdkSession: async (input) => (client.attachSdkSession(input)),
+        detachSdkSession: async (input) => (client.detachSdkSession(input)),
+        deleteSdkSession: async (input) => (client.deleteSdkSession(input)),
+        cleanSdkSessions: async (input) => (client.cleanSdkSessions(input)),
+        listSdkCheckpoints: async (input) => (client.listSdkCheckpoints(input)),
+        restoreSdkCheckpoint: async (input) => (client.restoreSdkCheckpoint(input)),
+        deleteSdkCheckpoint: async (input) => (client.deleteSdkCheckpoint(input)),
+        readSdkTaskOutput: async (input) => (client.readSdkTaskOutput(input)),
+        stopSdkTask: async (input) => (client.stopSdkTask(input)),
+    };
+    const acp = {
+        listAgents: async () => ({ success: true, agents: (await acpProviders(client)).map(toLegacyAgentView) }),
+        /**
+         * The provider catalog changed — by ANY surface, or by the host itself.
+         *
+         * A surface reloads after its own edits already; this is for everyone
+         * else's, which is the case a multi-surface product has and a single-window
+         * one does not.
+         */
+        subscribeCatalogChanged: (listener) => {
+            catalogListeners.add(listener);
+            return () => { catalogListeners.delete(listener); };
+        },
+        getAgent: async (id) => {
+            const provider = (await acpProviders(client)).find((entry) => acpConfigId(entry.id) === id);
+            return provider
+                ? { success: true, agent: toLegacyAgentView(provider) }
+                : { success: false, error: 'ACP provider was not found.' };
+        },
+        getProviderModels: async (id) => {
+            const provider = (await acpProviders(client)).find((entry) => acpConfigId(entry.id) === id);
+            if (!provider)
+                return { success: false, error: 'ACP provider was not found.' };
+            return {
+                success: true,
+                result: {
+                    success: true,
+                    modelDiscovery: {
+                        models: provider.models.map(toLegacyModel),
+                        defaultModelId: provider.defaultModelId,
+                    },
+                },
+            };
+        },
+        runAgentPrompt: async (params) => runAcpPrompt(client, activeConversations, pendingCancellations, params),
+        cancelAgentPrompt: async (params) => cancelAcpPrompt(client, activeConversations, pendingCancellations, params),
+        // `acp.closeConversation` is deliberately ABSENT: the versioned host protocol has
+        // no command that reaches `AcpSessionService.closeConversation`, so this surface
+        // genuinely cannot terminate a conversation's ACP sessions. A stub returning
+        // `{ success: true, closedSessionCount: 0 }` told callers the sessions had been
+        // closed while the agent processes kept running. Callers feature-detect instead.
+        listProviderCatalog: async () => ({
+            success: true,
+            catalog: {
+                acpEnabled: true,
+                source: 'fallback',
+                refreshedAt: new Date().toISOString(),
+                entries: (await acpProviders(client)).map(toLegacyCatalogEntry),
+                syncErrors: [],
+            },
+        }),
+        syncProviderCatalog: async () => unsupported('ACP catalog mutation'),
+        setProviderCatalogEnabled: async () => unsupported('ACP catalog mutation'),
+        setCatalogProviderEnabled: async () => unsupported('ACP catalog mutation'),
+        updateCatalogProvider: async () => unsupported('ACP catalog mutation'),
+        setPreferredCatalogProvider: async () => unsupported('ACP catalog mutation'),
+        saveAgent: async () => unsupported('ACP registry mutation'),
+        createFixtureAgent: async () => unsupported('ACP registry mutation'),
+        createLocalProviderAgent: async () => unsupported('ACP registry mutation'),
+        removeAgent: async () => ({ ...unsupported('ACP registry mutation'), removed: false }),
+        testAgent: async () => ({ ...unsupported('ACP diagnostics'), updateCount: 0, diagnostics: {} }),
+        certifyAgent: async () => unsupported('ACP certification'),
+        approveProvider: async (id, providerId) => approveAcpProvider(client, id, providerId, 'approve'),
+        revokeProvider: async (id, providerId) => approveAcpProvider(client, id, providerId, 'revoke'),
+        getDiagnostics: async () => unsupported('ACP diagnostics'),
+    };
+    const workspaceError = 'Workspace tools are not available on this host yet.';
+    const workspace = {
+        pickDirectory: options.shell?.pickDirectory
+            || (async () => ({ success: false, path: null, error: workspaceError })),
+        pickExecutable: options.shell?.pickExecutable
+            || (async () => ({ success: false, path: null, error: workspaceError })),
+        listDirectory: async (input) => client.listWorkspaceDirectory({
+            ...workspaceAccessInput(input),
+            dirPath: input.dirPath,
+        }),
+        readFile: async (input) => client.readWorkspaceFile({
+            ...workspaceAccessInput(input),
+            path: input.path,
+        }),
+        getFileOpenOptions: options.shell?.getFileOpenOptions || (async () => ({
+            success: false,
+            path: null,
+            defaultApp: null,
+            options: [],
+            revealLabel: 'Open in Explorer',
+            error: workspaceError,
+        })),
+        openFileWith: options.shell?.openFileWith
+            || (async () => ({ success: false, path: null, target: null, error: workspaceError })),
+        runCommand: async (input) => client.runWorkspaceCommand({
+            ...workspaceAccessInput(input),
+            command: input.command,
+            ...(input.cwd ? { cwd: input.cwd } : {}),
+            ...(input.timeoutMs ? { timeoutMs: input.timeoutMs } : {}),
+        }),
+        terminalStart: async (input) => client.startWorkspaceTerminal({
+            ...workspaceAccessInput(input),
+            command: input.command,
+            ...(input.cwd ? { cwd: input.cwd } : {}),
+            ...(input.timeoutMs ? { timeoutMs: input.timeoutMs } : {}),
+        }),
+        terminalStop: async (input) => client.stopWorkspaceTerminal({
+            ...workspaceAccessInput(input),
+            terminalId: input.terminalId,
+        }),
+        ptyStart: async (input) => client.startWorkspacePty({
+            ...workspaceAccessInput(input),
+            ...(input.cwd ? { cwd: input.cwd } : {}),
+            ...(input.cols ? { cols: input.cols } : {}),
+            ...(input.rows ? { rows: input.rows } : {}),
+        }),
+        ptySnapshot: async (input) => client.snapshotWorkspacePty({
+            ...workspaceAccessInput(input),
+            terminalId: input.terminalId,
+        }),
+        ptyInput: async (input) => client.inputWorkspacePty({
+            ...workspaceAccessInput(input),
+            terminalId: input.terminalId,
+            data: input.data,
+        }),
+        ptyResize: async (input) => client.resizeWorkspacePty({
+            ...workspaceAccessInput(input),
+            terminalId: input.terminalId,
+            cols: input.cols,
+            rows: input.rows,
+        }),
+        ptyClear: async (input) => client.clearWorkspacePty({
+            ...workspaceAccessInput(input),
+            terminalId: input.terminalId,
+        }),
+        ptyStop: async (input) => client.stopWorkspacePty({
+            ...workspaceAccessInput(input),
+            terminalId: input.terminalId,
+        }),
+        browserRegister: async () => ({ success: false, error: workspaceError }),
+        browserUnregister: async () => ({ success: false, error: workspaceError }),
+        browserList: async () => ({ success: false, tabs: [], error: workspaceError }),
+        browserSnapshot: async () => ({ success: false, snapshot: null, error: workspaceError }),
+        browserGoto: async () => ({ success: false, error: workspaceError }),
+        browserClick: async () => ({ success: false, error: workspaceError }),
+        browserType: async () => ({ success: false, error: workspaceError }),
+        browserKey: async () => ({ success: false, error: workspaceError }),
+        onPtyData: (callback) => { ptyDataListeners.add(callback); },
+        offPtyData: () => { ptyDataListeners.clear(); },
+        onPtyExit: (callback) => { ptyExitListeners.add(callback); },
+        offPtyExit: () => { ptyExitListeners.clear(); },
+        onTerminalData: (callback) => { terminalDataListeners.add(callback); },
+        offTerminalData: () => { terminalDataListeners.clear(); },
+        onTerminalExit: (callback) => { terminalExitListeners.add(callback); },
+        offTerminalExit: () => { terminalExitListeners.clear(); },
+        writeFile: async (input) => client.writeWorkspaceFile({
+            ...workspaceAccessInput(input),
+            path: input.path,
+            content: input.content,
+        }),
+        openApp: options.shell?.openApp
+            || (async () => ({ success: false, appPath: null, error: workspaceError })),
+    };
+    const engineering = {
+        gitStatus: (input) => client.requestEngineering('engineering.git.status', input),
+        gitDiff: (input) => client.requestEngineering('engineering.git.diff', input),
+        gitStage: (input) => client.requestEngineering('engineering.git.stage', input),
+        gitUnstage: (input) => client.requestEngineering('engineering.git.unstage', input),
+        gitCommit: (input) => client.requestEngineering('engineering.git.commit', input),
+        gitBranch: (input) => client.requestEngineering('engineering.git.branch', input),
+        gitPush: (input) => client.requestEngineering('engineering.git.push', input),
+        gitCreatePullRequest: (input) => client.requestEngineering('engineering.git.pr.create', input),
+        landingEnqueue: (input) => client.requestEngineering('engineering.landing.enqueue', input),
+        landingRemove: (input) => client.requestEngineering('engineering.landing.remove', input),
+        landingStatus: (input) => client.requestEngineering('engineering.landing.status', input),
+        landingVerify: (input) => client.requestEngineering('engineering.landing.verify', input),
+        landingLand: (input) => client.requestEngineering('engineering.landing.land', input),
+        discoverChecks: (input) => client.requestEngineering('engineering.checks.discover', input),
+        runCheck: (input) => client.requestEngineering('engineering.checks.run', input),
+        startBackgroundCheck: (input) => client.requestEngineering('engineering.background.start', input),
+        listBackgroundRuns: (input) => client.requestEngineering('engineering.background.list', input),
+        readBackgroundRunOutput: (input) => client.requestEngineering('engineering.background.output', input),
+        stopBackgroundRun: (input) => client.requestEngineering('engineering.background.stop', input),
+        listRuns: (input) => client.requestEngineering('engineering.runs.list', input),
+        diagnostics: (input) => client.requestEngineering('engineering.diagnostics', input),
+        listPatchReviews: (input) => client.requestEngineering('engineering.patches.list', input),
+        enqueuePatchReview: (input) => client.requestEngineering('engineering.patches.enqueue', input),
+        updatePatchReview: (input) => client.requestEngineering('engineering.patches.update', input),
+        reviewPatchSelection: (input) => client.requestEngineering('engineering.patches.review', input),
+        listCheckpoints: (input) => client.requestEngineering('engineering.checkpoints.list', input),
+        compareCheckpoints: (input) => client.requestEngineering('engineering.checkpoints.compare', input),
+        restoreCheckpoint: (input) => client.requestEngineering('engineering.checkpoints.restore', input),
+        listSessions: (input) => client.requestEngineering('engineering.sessions.list', input),
+        runtimeTimeline: (input) => client.requestEngineering('engineering.runtime.timeline', input),
+    };
+    const knowledge = {
+        list: (input) => client.requestKnowledge('knowledge.list', input),
+        record: (input) => client.requestKnowledge('knowledge.record', input),
+        forget: (input) => client.requestKnowledge('knowledge.forget', input),
+        context: (input) => client.requestKnowledge('knowledge.context', input),
+    };
+    const intake = {
+        sources: (input) => client.requestIntake('intake.sources.list', input),
+        list: (input) => client.requestIntake('intake.items.list', input),
+        claim: (input) => client.requestIntake('intake.item.claim', input),
+        release: (input) => client.requestIntake('intake.item.release', input),
+        dispatch: (input) => client.requestIntake('intake.item.dispatch', input),
+    };
+    const session = {
+        list: (input) => client.requestSession('session.list', input),
+        attach: (input) => client.requestSession('session.attach', input),
+        detach: (input) => client.requestSession('session.detach', input),
+        snapshot: (input) => client.requestSession('session.snapshot', input),
+        /**
+         * 🔴 The ORDINARY typing path, and it was bound nowhere.
+         *
+         * Six of the seven session methods were on this bridge and this one was
+         * not, so the only way a surface could type was `takeover` — which seizes
+         * the write lease and records an intervention, because §5.5 is explicit
+         * that typing IS the takeover. Every keystroke read as "this agent is going
+         * wrong now".
+         */
+        /**
+         * 🔴 The command context is minted HERE, not asked of the caller.
+         *
+         * A fresh id per send, because two identical keystrokes are two inputs and
+         * a shared idempotency key would make the second one a replay of the first.
+         * Minting it in the transport also means no surface can forget the field —
+         * the reason this method sat unbound is that its request was hard to
+         * satisfy from a panel.
+         */
+        input: (input) => client.requestSession('session.input', {
+            ...input,
+            command: {
+                schemaVersion: 1,
+                commandId: `session-input-${++subscriptionSequence}-${client.instanceId}`,
+                idempotencyKey: `session-input-${subscriptionSequence}-${client.instanceId}`,
+                client: client.clientIdentity,
+            },
+        }),
+        takeover: (input) => client.requestSession('session.takeover', input),
+        /**
+         * Fires when a session opens, closes, or gains or loses a viewer.
+         *
+         * Returns its own unsubscribe rather than taking an id, because there is
+         * exactly one caller shape — a panel that mounts and unmounts — and an id
+         * table would be a second thing to keep in sync with it.
+         */
+        subscribeChanged: (listener) => {
+            sessionListeners.add(listener);
+            return () => { sessionListeners.delete(listener); };
+        },
+        release: (input) => client.requestSession('session.release', input),
+    };
+    const fleet = {
+        view: (input) => client.requestFleet('fleet.view', input),
+        /** Fires when anything a board row is composed from moves. See the router. */
+        subscribeChanged: (listener) => {
+            fleetListeners.add(listener);
+            return () => { fleetListeners.delete(listener); };
+        },
+    };
+    const review = {
+        snapshot: (input) => client.requestRunObservation('run.observation.snapshot', input),
+        change: (input) => client.requestRunObservation('run.observation.change', input),
+        overlaps: (input) => client.requestRunObservation('run.observation.overlaps', input),
+        /**
+         * A run's tier-1 change set moved — §2.9.
+         *
+         * The payload carries the run it belongs to; a subscriber watching ONE run
+         * filters for itself, because a review pane must not re-read a diff because
+         * some other run wrote a file.
+         */
+        subscribeChanged: (listener) => {
+            observationListeners.add(listener);
+            return () => { observationListeners.delete(listener); };
+        },
+    };
+    const bridge = {
+        debug: {
+            log: options.log || ((scope, message, meta) => {
+                console.debug(`[${scope}] ${message}`, meta || '');
+            }),
+        },
+        updater: {
+            // Only `check` and `getVersion` exist here. `download`/`install` and the update
+            // lifecycle listeners are deliberately ABSENT: this host runs no update pipeline,
+            // and no-op implementations would have accepted a download request or an update
+            // listener that could never resolve or fire.
+            check: async () => unsupported('Updater'),
+            getVersion: async () => options.appVersion || '0.0.0',
+        },
+        agentContext: {
+            // No host command reports installed apps or the signed-in user, so this
+            // reports failure rather than an authoritative-looking empty machine.
+            get: async () => ({ ...unsupported('Agent runtime context'), context: null }),
+        },
+        workspaceStorage: {
+            save: async (workspaces) => client.saveWorkspaces(Array.isArray(workspaces) ? workspaces : []),
+            load: async () => client.loadWorkspaces(),
+            // `onChanged`/`offChanged` are deliberately ABSENT: the host emits no
+            // workspace-state change event, so cross-surface workspace reload cannot work
+            // here. No-op registrars satisfied every existence check while guaranteeing the
+            // callback would never fire; callers feature-detect instead.
+        },
+        agentStorage: {
+            saveConversation: async (conversation) => client.saveConversation(conversation),
+            loadConversations: async () => client.loadConversations(),
+            deleteConversation: async (id) => client.deleteConversation(id),
+        },
+        runtimeEvents: {
+            append: async () => unsupported('Renderer-authored runtime events'),
+            list: async (params) => {
+                try {
+                    const result = await client.listRuntimeEvents(toRuntimeEventListRequest(params));
+                    return { success: true, events: result.events };
+                }
+                catch (error) {
+                    return { success: false, events: [], error: safeError(error) };
+                }
+            },
+            listSubagentTrace: async (params) => {
+                try {
+                    const result = await client.listRuntimeEvents(toRuntimeEventListRequest(params));
+                    return { success: true, events: result.events };
+                }
+                catch (error) {
+                    return { success: false, events: [], error: safeError(error) };
+                }
+            },
+            project: async () => unsupported('Host runtime projection'),
+            repair: async () => unsupported('Runtime-event repair'),
+            subscribeAppended: (callback) => (addSubscription(runtimeSubscriptions, callback, () => ++subscriptionSequence, 'runtime')),
+            unsubscribeAppended: (id) => runtimeSubscriptions.delete(id),
+        },
+        workspace,
+        engineering,
+        review,
+        fleet,
+        session,
+        intake,
+        knowledge,
+        agent,
+        acp,
+    };
+    return {
+        bridge,
+        dispose() {
+            unsubscribe();
+            runtimeListeners.clear();
+            errorListeners.clear();
+            chooseDirectoryListeners.clear();
+            workspacePlacementListeners.clear();
+            permissionListeners.clear();
+            askUserListeners.clear();
+            taskListeners.clear();
+            runtimeSubscriptions.clear();
+            chooseDirectorySubscriptions.clear();
+            workspacePlacementSubscriptions.clear();
+            terminalDataListeners.clear();
+            terminalExitListeners.clear();
+            ptyDataListeners.clear();
+            ptyExitListeners.clear();
+            activeConversations.clear();
+            pendingCancellations.clear();
+        },
+    };
+}
+function routeHostEvent(event, state) {
+    /**
+     * Sessions changed — ADE §2.8.
+     *
+     * 🔴 The host has always published these and NOTHING listened, so a panel
+     * that read `session.list` once on mount never learned about a session opened
+     * afterwards. Since a run gets its session at turn start, that is every
+     * session but the ones that already existed — the list was correct only for
+     * an instant.
+     *
+     * IDS AND COUNTS ONLY, which is why this is safe to broadcast. Terminal bytes
+     * are per-viewer and large, and the substrate deliberately keeps them off the
+     * event feed; `session.snapshot` is the read path for output and stays a poll.
+     */
+    /**
+     * The provider catalog changed — a provider was registered, removed, or the
+     * catalog reloaded.
+     *
+     * 🔴 Published since the host existed and routed NOWHERE, which matters
+     * because this repo is explicitly multi-surface: standalone, Hub, and Shell
+     * next. A list of agents is self-consistent only for the surface that changed
+     * it — the store reloads after its OWN mutations — so another window adding
+     * an ACP agent left every other window showing a catalog that no longer
+     * exists. That is a designed scenario here, not a hypothetical one.
+     */
+    if (event.type === 'provider.catalog.changed') {
+        for (const listener of [...state.catalogListeners])
+            listener(event.payload);
+        return;
+    }
+    if (event.type === 'session.event') {
+        for (const listener of [...state.sessionListeners])
+            listener(event.payload);
+        return;
+    }
+    /**
+     * The fleet board changed — ADE §5.2/§5.4.
+     *
+     * 🔴 TWO event types, ONE subscription, because a board row is composed from
+     * both: `coordination.event` moves claims, collisions and run state;
+     * `run.observation` moves the change counts and whether the diff can be
+     * trusted. A surface subscribing to only one would be right about half of
+     * each row.
+     *
+     * ⚠️ This corrects a note left last iteration, which said a live
+     * coordination feed was unnecessary "because the fleet board polls
+     * `fleet.view`". It does not poll. It read once on mount, so the board was
+     * accurate for an instant and then silently stale — the same defect the
+     * sessions panel had, in the surface a person uses to decide whether work is
+     * safe to land.
+     */
+    if (event.type === 'coordination.event' || event.type === 'run.observation') {
+        for (const listener of [...state.fleetListeners])
+            listener(event.payload);
+        /**
+         * 🔴 `run.observation` reaches TWO surfaces, and they want different
+         * slices of it. The board wants every run's counts; a review pane wants one
+         * run's diff. Both read the same event and each filters for itself, rather
+         * than the router deciding — it does not know which run anyone is looking
+         * at.
+         */
+        if (event.type === 'run.observation') {
+            for (const listener of [...state.observationListeners])
+                listener(event.payload);
+        }
+        return;
+    }
+    if (event.type === 'runtime.event.appended') {
+        const payload = asRecord(event.payload);
+        const envelope = asRecord(payload.event);
+        const requestId = cleanString(payload.requestId) || cleanString(envelope.requestId);
+        if (!requestId || !isRecord(envelope.event))
+            return;
+        const legacyPayload = { requestId, event: structuredClone(envelope.event) };
+        for (const listener of [...state.runtimeListeners])
+            listener(legacyPayload);
+        for (const listener of [...state.runtimeSubscriptions.values()]) {
+            listener({ requestId, event: structuredClone(envelope) });
+        }
+        if (isTerminalEvent(envelope.event))
+            state.activeConversations.delete(requestId);
+        return;
+    }
+    if (event.type === 'turn.execution.completed') {
+        // The host's own terminal signal. `isTerminalEvent` below still clears on provider-specific
+        // strings, and deliberately stays: it is the fine-grained stream. This is the coarse fact
+        // that does not depend on knowing which provider ran, so a turn whose adapter emits a
+        // terminal type this bridge has never heard of no longer appears to run forever.
+        const requestId = cleanString(asRecord(event.payload).requestId);
+        if (requestId)
+            state.activeConversations.delete(requestId);
+        return;
+    }
+    if (event.type === 'turn.execution.abandoned') {
+        // 🔴 Surfaced as an ERROR, not a quiet clear. The host stopped tracking the turn and
+        // released its capacity, but the adapter may still be running — so silently dropping it
+        // would show the user a finished turn while work continues behind them. Saying so is the
+        // whole point of the event existing.
+        const payload = asRecord(event.payload);
+        const requestId = cleanString(payload.requestId);
+        if (!requestId)
+            return;
+        const failure = {
+            requestId,
+            error: cleanString(payload.safeError)
+                || 'The Agent host stopped tracking this turn. The runtime may still be running.',
+            context: 'host',
+        };
+        for (const listener of [...state.errorListeners])
+            listener(failure);
+        state.activeConversations.delete(requestId);
+        return;
+    }
+    if (event.type === 'turn.execution.failed') {
+        const payload = asRecord(event.payload);
+        const requestId = cleanString(payload.requestId);
+        if (!requestId)
+            return;
+        const failure = {
+            requestId,
+            error: cleanString(payload.safeError) || 'The Agent host could not execute this turn.',
+            context: 'host',
+        };
+        for (const listener of [...state.errorListeners])
+            listener(failure);
+        state.activeConversations.delete(requestId);
+        return;
+    }
+    if (event.type === 'elicitation.choose-directory.requested') {
+        const payload = asRecord(event.payload);
+        const requestId = cleanString(payload.requestId);
+        const chooseDirectoryId = cleanString(payload.chooseDirectoryId);
+        if (!requestId || !chooseDirectoryId)
+            return;
+        const normalized = {
+            requestId,
+            chooseDirectoryId,
+            ...(cleanString(payload.title) ? { title: cleanString(payload.title) } : {}),
+        };
+        for (const listener of [...state.chooseDirectoryListeners])
+            listener(normalized);
+        for (const listener of [...state.chooseDirectorySubscriptions.values()])
+            listener(normalized);
+        return;
+    }
+    if (event.type === 'elicitation.workspace-placement.requested') {
+        const payload = asRecord(event.payload);
+        const requestId = cleanString(payload.requestId);
+        const workspacePlacementId = cleanString(payload.workspacePlacementId);
+        const directory = cleanString(payload.directory);
+        if (!requestId || !workspacePlacementId || !directory)
+            return;
+        const normalized = {
+            requestId,
+            workspacePlacementId,
+            directory,
+            ...(cleanString(payload.title) ? { title: cleanString(payload.title) } : {}),
+        };
+        for (const listener of [...state.workspacePlacementListeners])
+            listener(normalized);
+        for (const listener of [...state.workspacePlacementSubscriptions.values()])
+            listener(normalized);
+        return;
+    }
+    if (event.type === 'elicitation.permission.requested') {
+        const payload = asRecord(event.payload);
+        const requestId = cleanString(payload.requestId);
+        const permissionId = cleanString(payload.permissionId);
+        const toolName = cleanString(payload.toolName);
+        const path = cleanString(payload.path, 100_000);
+        const directory = cleanString(payload.directory, 2_000);
+        // Identity is required — without a requestId the surface cannot attach the
+        // prompt to a conversation, and without a permissionId it cannot be
+        // answered. `path` and `directory` are NOT required: an ACP `execute` call
+        // legitimately names no file, and dropping those events silently is how a
+        // permission prompt goes missing rather than being refused.
+        if (!requestId || !permissionId || !toolName)
+            return;
+        const normalized = {
+            requestId,
+            permissionId,
+            toolName,
+            // Empty is a truthful "none" here. Inventing a directory would be worse
+            // than an empty one: the SDK-native lane widens a real grant from this
+            // field, so a fabricated value could authorise a directory nobody chose.
+            path: path || '',
+            directory: directory || '',
+            ...(cleanString(payload.allowAlwaysOptionId, 500)
+                ? { allowAlwaysOptionId: cleanString(payload.allowAlwaysOptionId, 500) }
+                : {}),
+            ...(cleanString(payload.rejectAlwaysOptionId, 500)
+                ? { rejectAlwaysOptionId: cleanString(payload.rejectAlwaysOptionId, 500) }
+                : {}),
+            ...(cleanString(payload.browserOrigin, 2_000)
+                ? { browserOrigin: cleanString(payload.browserOrigin, 2_000) }
+                : {}),
+        };
+        for (const listener of [...state.permissionListeners])
+            listener(normalized);
+        return;
+    }
+    if (event.type === 'elicitation.ask-user.requested') {
+        const payload = asRecord(event.payload);
+        const requestId = cleanString(payload.requestId);
+        const askUserId = cleanString(payload.askUserId);
+        const question = cleanString(payload.question, 100_000);
+        if (!requestId || !askUserId || !question)
+            return;
+        const options = stringArray(payload.options, 100, 10_000);
+        const normalized = {
+            requestId,
+            askUserId,
+            question,
+            ...(options.length > 0 ? { options } : {}),
+            ...(cleanString(payload.context, 100_000) ? { context: cleanString(payload.context, 100_000) } : {}),
+        };
+        for (const listener of [...state.askUserListeners])
+            listener(normalized);
+        return;
+    }
+    if (event.type === 'task.changed') {
+        const payload = asRecord(event.payload);
+        const requestId = cleanString(payload.requestId);
+        const action = payload.action === 'create' || payload.action === 'update' || payload.action === 'clear'
+            ? payload.action
+            : undefined;
+        if (!requestId || !action)
+            return;
+        const normalized = {
+            requestId,
+            action,
+            ...(isRecord(payload.task) ? { task: structuredClone(payload.task) } : {}),
+            ...(cleanString(payload.taskId) ? { taskId: cleanString(payload.taskId) } : {}),
+            ...(isRecord(payload.patch) ? { patch: structuredClone(payload.patch) } : {}),
+        };
+        for (const listener of [...state.taskListeners])
+            listener(normalized);
+        return;
+    }
+    const payload = asRecord(event.payload);
+    const ownerInstanceId = cleanString(payload.ownerInstanceId);
+    if (ownerInstanceId && ownerInstanceId !== state.clientInstanceId)
+        return;
+    if (event.type === 'workspace.terminal.data') {
+        const terminalId = cleanString(payload.terminalId);
+        const stream = payload.stream === 'stderr' ? 'stderr' : payload.stream === 'stdout' ? 'stdout' : undefined;
+        if (!terminalId || !stream || typeof payload.chunk !== 'string')
+            return;
+        for (const listener of [...state.terminalDataListeners]) {
+            listener({ terminalId, stream, chunk: payload.chunk });
+        }
+        return;
+    }
+    if (event.type === 'workspace.terminal.exit') {
+        const terminalId = cleanString(payload.terminalId);
+        const command = cleanString(payload.command, 100_000);
+        const cwd = cleanString(payload.cwd, 2_000);
+        if (!terminalId || !command || !cwd)
+            return;
+        const normalized = {
+            terminalId,
+            command,
+            cwd,
+            success: payload.success === true,
+            exitCode: typeof payload.exitCode === 'number' ? payload.exitCode : null,
+            error: typeof payload.error === 'string' ? payload.error : null,
+        };
+        for (const listener of [...state.terminalExitListeners])
+            listener(normalized);
+        return;
+    }
+    if (event.type === 'workspace.pty.data') {
+        const terminalId = cleanString(payload.terminalId);
+        if (!terminalId || typeof payload.data !== 'string')
+            return;
+        for (const listener of [...state.ptyDataListeners])
+            listener({ terminalId, data: payload.data });
+        return;
+    }
+    if (event.type === 'workspace.pty.exit') {
+        const terminalId = cleanString(payload.terminalId);
+        if (!terminalId || typeof payload.exitCode !== 'number')
+            return;
+        const normalized = {
+            terminalId,
+            exitCode: payload.exitCode,
+            ...(typeof payload.signal === 'number' ? { signal: payload.signal } : {}),
+        };
+        for (const listener of [...state.ptyExitListeners])
+            listener(normalized);
+    }
+}
+function workspaceAccessInput(value) {
+    const input = asRecord(value);
+    const caller = asRecord(input.caller);
+    return {
+        allowedDirectories: stringArray(input.allowedDirs ?? input.allowedDirectories ?? caller.allowedDirectories, 100, 2_000),
+        ...(cleanString(input.conversationId, 500) ? { conversationId: cleanString(input.conversationId, 500) } : {}),
+        ...(cleanString(input.workspaceId, 500) || cleanString(caller.workspaceId, 500)
+            ? { workspaceId: cleanString(input.workspaceId, 500) || cleanString(caller.workspaceId, 500) }
+            : {}),
+        ...(cleanString(input.teamId, 500) || cleanString(caller.teamId, 500)
+            ? { teamId: cleanString(input.teamId, 500) || cleanString(caller.teamId, 500) }
+            : {}),
+        ...(cleanString(input.agentId, 500) || cleanString(caller.agentId, 500)
+            ? { agentId: cleanString(input.agentId, 500) || cleanString(caller.agentId, 500) }
+            : {}),
+    };
+}
+async function runAcpPrompt(client, activeConversations, pendingCancellations, value) {
+    const params = asRecord(value);
+    const requestId = cleanString(params.requestId);
+    const conversationId = cleanString(params.conversationId);
+    const configId = cleanString(params.acpAgentConfigId) || cleanString(params.id);
+    const prompt = cleanString(params.prompt, 2_000_000);
+    if (!requestId || !conversationId || !configId || !prompt) {
+        return { success: false, error: 'ACP turn requires requestId, conversationId, provider, and prompt.' };
+    }
+    activeConversations.set(requestId, conversationId);
+    try {
+        const providers = await acpProviders(client);
+        const provider = providers.find((entry) => acpConfigId(entry.id) === configId);
+        if (!provider) {
+            activeConversations.delete(requestId);
+            return { success: false, error: 'The selected ACP provider is no longer available.' };
+        }
+        const selection = selectProviderRuntime(provider, cleanString(params.providerModel, 240));
+        if (pendingCancellations.has(requestId)) {
+            activeConversations.delete(requestId);
+            return { success: true, status: 'cancelled', events: [] };
+        }
+        const workspace = toWorkspace(params);
+        const continuation = toContinuation(params, provider.id);
+        const contextCompaction = isRecord(params.contextCompaction)
+            ? params.contextCompaction
+            : undefined;
+        const result = await client.startTurn({
+            conversationId,
+            requestId,
+            ...(cleanString(params.workspaceId, 500) ? { workspaceId: cleanString(params.workspaceId, 500) } : {}),
+            ...(cleanString(params.teamId, 500) ? { teamId: cleanString(params.teamId, 500) } : {}),
+            ...(cleanString(params.agentId, 500) ? { agentId: cleanString(params.agentId, 500) } : {}),
+            mode: workspace.primaryDirectory ? 'development' : 'chat',
+            selection,
+            prompt,
+            history: toTurnHistory(params.history),
+            ...(cleanString(params.systemPrompt, 2_000_000) ? { systemPrompt: cleanString(params.systemPrompt, 2_000_000) } : {}),
+            ...(Object.keys(workspace).length > 0 ? { workspace } : {}),
+            ...(continuation ? { continuation } : {}),
+            ...(contextCompaction ? { contextCompaction } : {}),
+            ...(positiveInteger(params.timeoutMs) ? { timeoutMs: positiveInteger(params.timeoutMs) } : {}),
+        });
+        if (!result.success) {
+            activeConversations.delete(requestId);
+            return { success: false, status: 'failed', error: result.safeError, events: [] };
+        }
+        return { success: true, status: result.status, events: [] };
+    }
+    catch (error) {
+        activeConversations.delete(requestId);
+        return { success: false, status: 'failed', error: safeError(error), events: [] };
+    }
+    finally {
+        pendingCancellations.delete(requestId);
+    }
+}
+async function runHostPrompt(client, activeConversations, pendingCancellations, value) {
+    const params = asRecord(value);
+    const requestId = cleanString(params.requestId);
+    const conversationId = cleanString(params.conversationId);
+    const requestedModel = cleanString(params.model, 240);
+    const requestedProviderId = cleanString(params.providerId, 240);
+    const providerKind = params.providerKind === 'xeno-cloud' ? 'xeno-cloud' : 'sdk-native';
+    const mode = params.mode === 'chat' || params.mode === 'development'
+        ? params.mode
+        : (providerKind === 'xeno-cloud' ? 'chat' : 'development');
+    const messages = toTurnHistory(params.messages) || [];
+    let lastUserIndex = -1;
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        if (messages[index]?.role === 'user') {
+            lastUserIndex = index;
+            break;
+        }
+    }
+    const prompt = lastUserIndex >= 0 ? messages[lastUserIndex]?.content : undefined;
+    if (!requestId || !conversationId || !requestedModel || !prompt) {
+        return {
+            success: false,
+            error: 'Host execution requires requestId, conversationId, model, and a user message.',
+        };
+    }
+    activeConversations.set(requestId, conversationId);
+    try {
+        const catalog = await client.listProviders({ includeUnavailable: true });
+        const provider = catalog.providers.find((entry) => (requestedProviderId ? entry.id === requestedProviderId : entry.kind === providerKind));
+        if (!provider) {
+            activeConversations.delete(requestId);
+            return { success: false, error: `The ${providerKind} runtime is not available from the owning Agent host.` };
+        }
+        const selection = selectProviderRuntime(provider, requestedModel);
+        if (pendingCancellations.has(requestId)) {
+            activeConversations.delete(requestId);
+            return { success: true, requestId };
+        }
+        const allowedDirectories = stringArray(params.allowedDirectories, 500, 2_000);
+        const permissionProfile = cleanString(params.permissionProfile, 80);
+        const capabilities = booleanRecord(params.capabilities);
+        const approvalRules = recordArray(params.approvalRules, 500);
+        const contextCompaction = isRecord(params.contextCompaction)
+            ? params.contextCompaction
+            : undefined;
+        const providerSessionId = providerKind === 'xeno-cloud'
+            ? cleanString(params.previousRunId, 500)
+            : cleanString(params.sdkSessionId, 500);
+        const result = await client.startTurn({
+            conversationId,
+            requestId,
+            ...(cleanString(params.workspaceId, 500) ? { workspaceId: cleanString(params.workspaceId, 500) } : {}),
+            ...(cleanString(params.teamId, 500) ? { teamId: cleanString(params.teamId, 500) } : {}),
+            ...(cleanString(params.agentId, 500) ? { agentId: cleanString(params.agentId, 500) } : {}),
+            ...(cleanString(params.subagentRunId, 500) ? { subagentRunId: cleanString(params.subagentRunId, 500) } : {}),
+            mode,
+            selection,
+            prompt,
+            ...(lastUserIndex > 0 ? { history: messages.slice(0, lastUserIndex) } : {}),
+            ...(cleanString(params.systemPrompt, 2_000_000) ? { systemPrompt: cleanString(params.systemPrompt, 2_000_000) } : {}),
+            workspace: {
+                ...(allowedDirectories[0] ? { primaryDirectory: allowedDirectories[0] } : {}),
+                ...(allowedDirectories.length > 1 ? { additionalDirectories: allowedDirectories.slice(1) } : {}),
+                ...(permissionProfile ? { permissionProfile } : {}),
+                filesystem: permissionProfile === 'read-only'
+                    || permissionProfile === 'plan'
+                    || capabilities?.fileWrite === false
+                    ? 'read-only'
+                    : 'workspace-write',
+            },
+            execution: {
+                ...(positiveInteger(params.maxIterations) ? { maxIterations: positiveInteger(params.maxIterations) } : {}),
+                enableThinking: params.enableThinking === true,
+                ...(capabilities ? { capabilities } : {}),
+                ...(approvalRules.length > 0 ? { approvalRules } : {}),
+            },
+            ...(contextCompaction ? { contextCompaction } : {}),
+            ...(providerSessionId
+                ? {
+                    continuation: {
+                        providerId: provider.id,
+                        providerSessionId,
+                    },
+                }
+                : {}),
+        });
+        if (!result.success) {
+            activeConversations.delete(requestId);
+            return { success: false, error: result.safeError };
+        }
+        return { success: true, requestId };
+    }
+    catch (error) {
+        activeConversations.delete(requestId);
+        return { success: false, error: safeError(error) };
+    }
+    finally {
+        pendingCancellations.delete(requestId);
+    }
+}
+async function cancelAcpPrompt(client, activeConversations, pendingCancellations, value) {
+    const params = asRecord(value);
+    const requestId = cleanString(params.requestId);
+    const conversationId = cleanString(params.conversationId) || (requestId ? activeConversations.get(requestId) : undefined);
+    if (!requestId || !conversationId) {
+        return { success: false, cancelled: false, error: 'ACP cancellation requires an active request and conversation.' };
+    }
+    pendingCancellations.add(requestId);
+    try {
+        const result = await client.cancelTurn({ conversationId, requestId, reason: cleanString(params.reason) });
+        if (result.success || (result.code === 'turn_not_active' && activeConversations.has(requestId))) {
+            return { success: true, cancelled: true };
+        }
+        pendingCancellations.delete(requestId);
+        return { success: false, cancelled: false, error: result.safeError };
+    }
+    catch (error) {
+        if (activeConversations.has(requestId))
+            return { success: true, cancelled: true };
+        pendingCancellations.delete(requestId);
+        return { success: false, cancelled: false, error: safeError(error) };
+    }
+}
+async function cancelByRequestId(client, activeConversations, pendingCancellations, requestId) {
+    const conversationId = activeConversations.get(requestId);
+    if (!conversationId)
+        return { success: false, error: 'The requested turn is not active.' };
+    pendingCancellations.add(requestId);
+    const result = await client.cancelTurn({ conversationId, requestId, reason: 'Cancelled from the Agent interface.' });
+    if (result.success || result.code === 'turn_not_active')
+        return { success: true };
+    pendingCancellations.delete(requestId);
+    return { success: false, error: result.safeError };
+}
+async function acpProviders(client) {
+    const result = await client.listProviders({ includeUnavailable: true });
+    return result.providers.filter((provider) => provider.kind === 'acp');
+}
+function selectProviderRuntime(provider, requestedModel) {
+    const direct = requestedModel ? provider.models.find((model) => model.id === requestedModel) : undefined;
+    const reasoning = requestedModel
+        ? provider.models.flatMap((model) => (model.reasoningOptions || []).map((option) => ({ model, option })))
+            .find(({ option }) => option.runtimeModelId === requestedModel || option.id === requestedModel)
+        : undefined;
+    const model = direct || reasoning?.model
+        || provider.models.find((entry) => entry.id === provider.defaultModelId)
+        || provider.models.find((entry) => entry.isDefault)
+        || provider.models.find((entry) => entry.availability === 'available');
+    return {
+        providerId: provider.id,
+        catalogRevision: provider.catalogRevision,
+        ...(model ? { modelId: model.id } : {}),
+        ...(reasoning ? { reasoningOptionId: reasoning.option.id } : {}),
+        ...(reasoning?.option.runtimeModelId ? { runtimeModelId: reasoning.option.runtimeModelId } : {}),
+    };
+}
+function toWorkspace(params) {
+    const execution = asRecord(params.execution);
+    const primaryDirectory = cleanString(params.cwd, 2_000);
+    const additionalDirectories = stringArray(params.additionalDirectories, 500, 2_000);
+    const permissionProfile = cleanString(execution.permissionProfile, 80);
+    const filesystem = execution.filesystem === 'workspace-write' ? 'workspace-write' : 'read-only';
+    return {
+        ...(primaryDirectory ? { primaryDirectory } : {}),
+        ...(additionalDirectories.length > 0 ? { additionalDirectories } : {}),
+        ...(permissionProfile ? { permissionProfile } : {}),
+        filesystem,
+    };
+}
+function toContinuation(params, providerId) {
+    const providerSessionId = cleanString(params.resumeSessionId, 500);
+    if (!providerSessionId)
+        return undefined;
+    const state = isRecord(params.resumeState) ? structuredClone(params.resumeState) : undefined;
+    return {
+        providerId,
+        providerSessionId,
+        ...(state ? { state } : {}),
+        ...(cleanString(params.resumeAgentConfigFingerprint, 500)
+            ? { providerConfigFingerprint: cleanString(params.resumeAgentConfigFingerprint, 500) }
+            : {}),
+        ...(cleanString(params.resumeWorkspaceFingerprint, 500)
+            ? { workspaceFingerprint: cleanString(params.resumeWorkspaceFingerprint, 500) }
+            : {}),
+    };
+}
+function toTurnHistory(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const messages = value.flatMap((entry) => {
+        const record = asRecord(entry);
+        if ((record.role !== 'user' && record.role !== 'assistant') || typeof record.content !== 'string')
+            return [];
+        return [{ role: record.role, content: record.content }];
+    });
+    return messages.length > 0 ? messages : undefined;
+}
+function toRuntimeEventListRequest(value) {
+    const params = asRecord(value);
+    const conversationId = cleanString(params.conversationId);
+    if (!conversationId)
+        throw new Error('conversationId is required to list runtime events.');
+    return {
+        conversationId,
+        ...(cleanString(params.requestId) ? { requestId: cleanString(params.requestId) } : {}),
+        ...(cleanString(params.subagentRunId) ? { subagentRunId: cleanString(params.subagentRunId) } : {}),
+        ...(cleanString(params.type) ? { type: cleanString(params.type) } : {}),
+        ...(nonNegativeInteger(params.afterSequence) !== undefined
+            ? { afterSequence: nonNegativeInteger(params.afterSequence) }
+            : {}),
+        ...(positiveInteger(params.limit) ? { limit: positiveInteger(params.limit) } : {}),
+    };
+}
+function toLegacyAgentView(provider) {
+    const id = acpConfigId(provider.id);
+    const now = new Date(0).toISOString();
+    return {
+        id,
+        name: provider.displayName,
+        command: 'host-managed',
+        args: [],
+        envKeys: [],
+        enabled: provider.availability !== 'blocked' && provider.availability !== 'unavailable',
+        trustLevel: 'restricted',
+        endpointKind: 'native-acp',
+        certification: {
+            status: provider.availability === 'available' ? 'certified' : 'not_certified',
+            notes: provider.safeUnavailableReason,
+        },
+        providerReview: {
+            providerId: id,
+            displayName: provider.displayName,
+            runnable: provider.availability === 'available',
+            approvalState: provider.availability === 'available' ? 'approved' : 'blocked',
+            runtimeEnvKeys: [],
+            requiredAuthRefs: [],
+            optionalAuthRefs: [],
+        },
+        createdAt: now,
+        updatedAt: now,
+    };
+}
+function toLegacyModel(model) {
+    return {
+        id: model.id,
+        label: model.displayName,
+        available: model.availability === 'available',
+        default: model.isDefault === true,
+        reason: model.safeUnavailableReason,
+        reasoningOptions: model.reasoningOptions?.map((option) => ({
+            id: option.id,
+            label: option.label,
+            modelId: option.runtimeModelId,
+            default: option.isDefault === true,
+        })),
+    };
+}
+function toLegacyCatalogEntry(provider) {
+    const id = acpConfigId(provider.id);
+    const ready = provider.availability === 'available';
+    return {
+        id,
+        name: provider.displayName,
+        description: provider.safeUnavailableReason || 'Host-managed ACP provider.',
+        authors: [],
+        distributionKind: 'custom',
+        installed: true,
+        configured: true,
+        enabled: ready,
+        preferred: false,
+        canAutoSetup: false,
+        availableActions: [],
+        agentConfigId: id,
+        status: ready ? 'ready' : 'needs_attention',
+        statusMessage: ready ? 'Ready' : (provider.safeUnavailableReason || 'Unavailable'),
+    };
+}
+function addSubscription(subscriptions, listener, nextSequence, prefix) {
+    const id = `${prefix}-${nextSequence()}`;
+    subscriptions.set(id, listener);
+    return id;
+}
+function acpConfigId(providerId) {
+    return providerId.startsWith('acp:') ? providerId.slice(4) : providerId;
+}
+function isTerminalEvent(event) {
+    return event.type === 'acp.session.completed'
+        || event.type === 'acp.session.failed'
+        || event.type === 'acp.session.cancelled'
+        || event.type === 'turn.completed'
+        || event.type === 'turn.failed'
+        || event.type === 'turn.cancelled';
+}
+function positiveInteger(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value > 0 ? value : undefined;
+}
+function nonNegativeInteger(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= 0 ? value : undefined;
+}
+function stringArray(value, limit, maxLength) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((entry) => {
+        const normalized = cleanString(entry, maxLength);
+        return normalized ? [normalized] : [];
+    }).slice(0, limit);
+}
+function booleanRecord(value) {
+    if (!isRecord(value))
+        return undefined;
+    const entries = Object.entries(value).filter((entry) => (typeof entry[1] === 'boolean'));
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+function recordArray(value, limit) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter(isRecord).slice(0, limit).map((entry) => structuredClone(entry));
+}
+function cleanString(value, maxLength = 500) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed ? trimmed.slice(0, maxLength) : undefined;
+}
+function safeError(error) {
+    return error instanceof Error && error.message.trim()
+        ? error.message.slice(0, 500)
+        : 'The XENO Agent host request failed.';
+}
+function asRecord(value) {
+    return isRecord(value) ? value : {};
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Routes provider approval to the host, which is the only place that may make
+ * this trust decision.
+ *
+ * Normalises a HOST-LEVEL failure (transport down, handshake missing) into the
+ * same `{success:false,error}` shape the store already handles, so a surface
+ * cannot tell "the host refused" from "the host was unreachable" by crashing.
+ */
+async function approveAcpProvider(client, agentId, providerId, action) {
+    try {
+        const result = await client.requestAcp('acp.provider.approve', {
+            agentId,
+            ...(providerId ? { providerId } : {}),
+            action,
+        });
+        if (!result.success) {
+            return { success: false, result, error: result.safeError ?? 'Provider approval failed.' };
+        }
+        return { success: true, result };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Provider approval could not reach the host.',
+        };
+    }
+}
+//# sourceMappingURL=agentHostPlatformBridge.js.map