maka-agent 0.2.0-dev.12.20260901 → 0.2.0-dev.14.20260902

package/THIRD_PARTY_NOTICES.txt

@@ -4108,7 +4108,7 @@ SOFTWARE.
 
 ================================================================================
 
-Package: fast-uri@3.1.5
+Package: fast-uri@3.1.7
 Declared license: BSD-3-Clause
 Selected license: BSD-3-Clause
 Repository: git+https://github.com/fastify/fast-uri.git
@@ -6483,7 +6483,7 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 ================================================================================
 
-Package: qs@6.15.3
+Package: qs@6.16.0
 Declared license: BSD-3-Clause
 Selected license: BSD-3-Clause
 Repository: https://github.com/ljharb/qs.git

package/dist/acp/maka-acp-agent.js

@@ -18,10 +18,13 @@
  */
 import { agent, methods } from '@agentclientprotocol/sdk';
 export function createMakaAcpAgent(options) {
-    return agent({ name: 'maka' }).onRequest(methods.agent.initialize, () => ({
+    return agent({ name: 'maka' })
+        .onRequest(methods.agent.initialize, () => ({
         protocolVersion: 1,
-        agentCapabilities: {},
+        agentCapabilities: { sessionCapabilities: { list: {} } },
         authMethods: [],
         agentInfo: { name: 'maka', title: 'Maka', version: options.version },
-    }));
+    }))
+        .onRequest(methods.agent.session.new, ({ params }) => options.sessionRegistry.create(params))
+        .onRequest(methods.agent.session.list, ({ params }) => options.sessionRegistry.list(params));
 }

package/dist/acp/session-registry.js

@@ -0,0 +1,307 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { randomUUID } from 'node:crypto';
+import { realpath } from 'node:fs/promises';
+import { isAbsolute, normalize } from 'node:path';
+import { RequestError, } from '@agentclientprotocol/sdk';
+import { readRuntimeHostSessionCatalogPage, RuntimeHostCatalogReadError, RuntimeHostOperationError, RuntimeHostRequestInterruptedError, RuntimeHostSessionCatalogRevisionChangedError, } from '@maka/runtime-host/client';
+import { SESSION_CATALOG_CURSOR_MAX_BYTES, SESSION_CATALOG_CWD_MAX_BYTES, } from '@maka/runtime-host/protocol';
+const ACP_SESSION_CURSOR_MAX_BYTES = 8 * 1024;
+/** Owns all Runtime Host resources associated with one ACP connection. */
+export class AcpSessionRegistry {
+    #connect;
+    #newSessionId;
+    #inFlightOperations = new Set();
+    #connection;
+    #connectTask;
+    #connectAbortController;
+    #closing = false;
+    #connectionCloseTask;
+    #disposeTask;
+    constructor(options) {
+        this.#connect = options.connect;
+        this.#newSessionId = options.newSessionId ?? randomUUID;
+    }
+    async create(params) {
+        this.#assertOpen('session.create');
+        validateNewSessionParams(params);
+        return this.#track(this.#create(params));
+    }
+    async list(params) {
+        this.#assertOpen('session.catalog.query');
+        return this.#track(this.#list(params));
+    }
+    dispose() {
+        this.#closing = true;
+        this.#connectAbortController?.abort();
+        this.#disposeTask ??= this.#dispose();
+        return this.#disposeTask;
+    }
+    async #create(params) {
+        const connection = await this.#getConnection('session.create');
+        const sessionId = this.#newSessionId();
+        try {
+            await connection.request('session.create', {
+                sessionId,
+                workspace: { kind: 'host_path', path: params.cwd },
+                modelTarget: { kind: 'default' },
+            });
+        }
+        catch (error) {
+            throw requestErrorFromRuntimeHost(error, 'session.create', { sessionId });
+        }
+        return { sessionId };
+    }
+    async #list(params) {
+        const cursor = params.cursor == null ? undefined : decodeAcpSessionCursor(params.cursor);
+        const requestedCwd = params.cwd == null ? undefined : await normalizeCwd(params.cwd);
+        if (cursor && requestedCwd !== undefined && cursor.cwd !== requestedCwd) {
+            throw RequestError.invalidParams({ reason: 'cursor_cwd_mismatch' }, 'cursor was created for a different cwd filter');
+        }
+        const cwd = requestedCwd ?? cursor?.cwd ?? null;
+        const connection = await this.#getConnection('session.catalog.query');
+        let page;
+        try {
+            page = await readRuntimeHostSessionCatalogPage(connection, cursor ? { revision: cursor.revision, cursor: cursor.cursor } : undefined);
+        }
+        catch (error) {
+            if (error instanceof RuntimeHostSessionCatalogRevisionChangedError) {
+                throw RequestError.invalidParams({ reason: 'stale_cursor' }, 'session catalog changed; restart listing from the first page');
+            }
+            throw requestErrorFromRuntimeHost(error, 'session.catalog.query');
+        }
+        const sessions = page.sessions.flatMap((session) => {
+            if ('kind' in session || (cwd !== null && session.workspace.hostCwd !== cwd))
+                return [];
+            const updatedAt = isoTimestamp(session.activityAt);
+            return [
+                {
+                    sessionId: session.id,
+                    cwd: session.workspace.hostCwd,
+                    title: session.name,
+                    ...(updatedAt ? { updatedAt } : {}),
+                },
+            ];
+        });
+        return {
+            sessions,
+            ...(page.nextCursor
+                ? { nextCursor: encodeAcpSessionCursor({ ...page.nextCursor, cwd }) }
+                : {}),
+        };
+    }
+    async #dispose() {
+        const connectionClose = this.#closeOwnedConnection();
+        await Promise.allSettled([connectionClose]);
+        await Promise.allSettled([...this.#inFlightOperations]);
+    }
+    #closeOwnedConnection() {
+        const connection = this.#connection;
+        const connectTask = this.#connectTask;
+        if (!connection && !connectTask)
+            return Promise.resolve();
+        this.#connectionCloseTask ??= connection
+            ? Promise.resolve().then(() => connection.close())
+            : connectTask.then((connected) => connected.close(), () => undefined);
+        return this.#connectionCloseTask;
+    }
+    async #getConnection(operation) {
+        this.#assertOpen(operation);
+        if (this.#connection)
+            return this.#connection;
+        let connectController = this.#connectAbortController;
+        if (!this.#connectTask) {
+            connectController = new AbortController();
+            this.#connectAbortController = connectController;
+            this.#connectTask = Promise.resolve().then(() => {
+                if (this.#closing)
+                    throw registryClosedError('connect');
+                connectController.signal.throwIfAborted();
+                return this.#connect(connectController.signal);
+            });
+        }
+        const connectTask = this.#connectTask;
+        let connection;
+        try {
+            connection = await connectTask;
+        }
+        catch {
+            if (this.#connectTask === connectTask)
+                this.#connectTask = undefined;
+            if (this.#connectAbortController === connectController) {
+                this.#connectAbortController = undefined;
+            }
+            if (this.#closing)
+                throw registryClosedError('connect');
+            throw RequestError.internalError({
+                source: 'runtime_host',
+                operation: 'connect',
+                code: 'connection_failed',
+            }, 'Runtime Host connection failed');
+        }
+        if (this.#connectAbortController === connectController) {
+            this.#connectAbortController = undefined;
+        }
+        if (this.#closing) {
+            await this.#closeOwnedConnection().catch(() => undefined);
+            throw registryClosedError('connect');
+        }
+        this.#connection ??= connection;
+        return this.#connection;
+    }
+    async #track(operation) {
+        this.#inFlightOperations.add(operation);
+        try {
+            return await operation;
+        }
+        finally {
+            this.#inFlightOperations.delete(operation);
+        }
+    }
+    #assertOpen(operation) {
+        if (!this.#closing)
+            return;
+        throw registryClosedError(operation);
+    }
+}
+function registryClosedError(operation) {
+    return RequestError.internalError({ source: 'runtime_host', operation, code: 'registry_closed' }, 'ACP session registry is closed');
+}
+function validateNewSessionParams(params) {
+    assertBoundedAbsoluteCwd(params.cwd);
+    if (params.mcpServers.length > 0) {
+        throw RequestError.invalidParams({ field: 'mcpServers', reason: 'unsupported' }, 'MCP servers are not supported by this ACP adapter yet');
+    }
+    if ((params.additionalDirectories?.length ?? 0) > 0) {
+        throw RequestError.invalidParams({ field: 'additionalDirectories', reason: 'unsupported' }, 'Additional directories are not supported by this ACP adapter yet');
+    }
+}
+function requestErrorFromRuntimeHost(error, operation, extra = {}) {
+    const data = { ...runtimeHostErrorData(error, operation), ...extra };
+    if (error instanceof RuntimeHostOperationError && error.code === 'invalid_request') {
+        return RequestError.invalidParams(data, 'Runtime Host rejected the request');
+    }
+    return RequestError.internalError(data, 'Runtime Host request failed');
+}
+function runtimeHostErrorData(error, operation) {
+    if (error instanceof RuntimeHostOperationError) {
+        return {
+            source: 'runtime_host',
+            operation: error.operation,
+            code: error.code,
+        };
+    }
+    if (error instanceof RuntimeHostRequestInterruptedError) {
+        return {
+            source: 'runtime_host',
+            operation: error.operation,
+            code: 'request_interrupted',
+            reason: error.reason,
+            dispatch: error.dispatch,
+        };
+    }
+    if (error instanceof RuntimeHostCatalogReadError) {
+        return {
+            source: 'runtime_host',
+            operation,
+            code: 'catalog_read_failure',
+            reason: error.reason,
+        };
+    }
+    return { source: 'runtime_host', operation, code: 'internal_failure' };
+}
+function encodeAcpSessionCursor(cursor) {
+    const encoded = Buffer.from(JSON.stringify(cursor), 'utf8').toString('base64url');
+    if (Buffer.byteLength(encoded, 'utf8') > ACP_SESSION_CURSOR_MAX_BYTES) {
+        throw RequestError.internalError({
+            source: 'runtime_host',
+            operation: 'session.catalog.query',
+            code: 'cursor_too_large',
+        }, 'Runtime Host cursor cannot be represented safely in ACP');
+    }
+    return encoded;
+}
+function decodeAcpSessionCursor(encoded) {
+    try {
+        if (encoded.length === 0 || Buffer.byteLength(encoded, 'utf8') > ACP_SESSION_CURSOR_MAX_BYTES) {
+            throw new Error('cursor size is invalid');
+        }
+        const decoded = Buffer.from(encoded, 'base64url');
+        if (decoded.toString('base64url') !== encoded)
+            throw new Error('cursor encoding is invalid');
+        const value = JSON.parse(decoded.toString('utf8'));
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            throw new Error('cursor body is invalid');
+        }
+        const record = value;
+        if (Object.keys(record).length !== 3 ||
+            typeof record.revision !== 'string' ||
+            !/^sha256:[0-9a-f]{64}$/.test(record.revision) ||
+            typeof record.cursor !== 'string' ||
+            record.cursor.length === 0 ||
+            Buffer.byteLength(record.cursor, 'utf8') > SESSION_CATALOG_CURSOR_MAX_BYTES ||
+            !validCursorCwd(record.cwd)) {
+            throw new Error('cursor fields are invalid');
+        }
+        return {
+            revision: record.revision,
+            cursor: record.cursor,
+            cwd: record.cwd,
+        };
+    }
+    catch {
+        throw RequestError.invalidParams({ reason: 'invalid_cursor' }, 'cursor is invalid');
+    }
+}
+function validCursorCwd(value) {
+    return (value === null ||
+        (typeof value === 'string' &&
+            isAbsolute(value) &&
+            normalize(value) === value &&
+            Buffer.byteLength(value, 'utf8') <= SESSION_CATALOG_CWD_MAX_BYTES));
+}
+async function normalizeCwd(cwd) {
+    assertBoundedAbsoluteCwd(cwd);
+    const lexical = normalize(cwd);
+    try {
+        return await realpath(lexical);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'ENOENT' || code === 'ENOTDIR')
+            return lexical;
+        throw RequestError.internalError({
+            source: 'filesystem',
+            operation: 'cwd.realpath',
+            code: code ?? 'internal_failure',
+        }, 'cwd could not be canonicalized');
+    }
+}
+function assertBoundedAbsoluteCwd(cwd) {
+    if (!isAbsolute(cwd)) {
+        throw RequestError.invalidParams({ field: 'cwd', reason: 'must_be_absolute' }, 'cwd must be an absolute path');
+    }
+    if (Buffer.byteLength(cwd, 'utf8') > SESSION_CATALOG_CWD_MAX_BYTES) {
+        throw RequestError.invalidParams({ field: 'cwd', reason: 'too_large' }, 'cwd exceeds the Runtime Host path limit');
+    }
+}
+function isoTimestamp(timestamp) {
+    const date = new Date(timestamp);
+    return Number.isNaN(date.getTime()) ? undefined : date.toISOString();
+}

package/dist/acp/stdio-server.js

@@ -19,7 +19,22 @@
 import { Readable, Writable } from 'node:stream';
 import { ndJsonStream } from '@agentclientprotocol/sdk';
 import { createMakaAcpAgent } from './maka-acp-agent.js';
+import { AcpSessionRegistry } from './session-registry.js';
+import { connectRuntimeHostCliConnection } from '../runtime-host-cli-context.js';
 export async function runMakaAcpStdioServer(input, dependencies = {}) {
+    const sessionRegistry = new AcpSessionRegistry({
+        connect: async (signal) => {
+            const context = await (dependencies.connectRuntimeHostCliConnection ?? connectRuntimeHostCliConnection)({
+                rootPath: input.workspaceRoot,
+                clientDataRoot: input.clientDataRoot,
+                signal,
+            });
+            return {
+                request: context.connection.request.bind(context.connection),
+                close: () => context.close(),
+            };
+        },
+    });
     const stdin = dependencies.stdin ?? process.stdin;
     const stdout = dependencies.stdout ?? process.stdout;
     let stdioError;
@@ -30,7 +45,10 @@ export async function runMakaAcpStdioServer(input, dependencies = {}) {
     stdout.once('error', recordStdioError);
     try {
         const stream = ndJsonStream(Writable.toWeb(stdout), Readable.toWeb(stdin));
-        const connection = createMakaAcpAgent({ version: input.version }).connect(stream);
+        const connection = createMakaAcpAgent({
+            version: input.version,
+            sessionRegistry,
+        }).connect(stream);
         await connection.closed;
         if (stdioError) {
             throw stdioError;
@@ -40,5 +58,6 @@ export async function runMakaAcpStdioServer(input, dependencies = {}) {
     finally {
         stdin.off('error', recordStdioError);
         stdout.off('error', recordStdioError);
+        await sessionRegistry.dispose();
     }
 }

package/dist/cli-core.js

@@ -94,7 +94,7 @@ function helpText(cliCommand) {
         '',
         'Commands:',
         `  ${cliCommand}              Start the TUI`,
-        `  ${cliCommand} --acp      Serve ACP v1 over stdio (initialize only; session support in progress)`,
+        `  ${cliCommand} --acp      Serve ACP v1 over stdio (initialize, session/new, session/list)`,
         `  ${cliCommand} run ...      Run one non-interactive model turn`,
         `  ${cliCommand} activate ... Run one Cloud Session activation and emit JSONL`,
         `  ${cliCommand} -p ...       Alias for ${cliCommand} run`,
@@ -116,6 +116,7 @@ function helpText(cliCommand) {
         `  ${cliCommand} runtime-host service reconcile-update [--json]`,
         `  ${cliCommand} runtime-host access issue --principal <id> --grant <operation>`,
         `  ${cliCommand} runtime-host access issue --principal <id> --preset <desktop-client|terminal-client>`,
+        `  ${cliCommand} runtime-host access connection-code [--name <name>] [--root <path>]`,
         `  ${cliCommand} runtime-host access list`,
         `  ${cliCommand} runtime-host access issue --kind capability-provider --principal <id>`,
         `  ${cliCommand} runtime-host access revoke --credential <id>`,
@@ -251,7 +252,11 @@ export async function runMakaCli(argv = process.argv.slice(2), options = RELEASE
         }
         case 'acp': {
             const { runMakaAcpStdioServer } = await import('./acp/stdio-server.js');
-            return runMakaAcpStdioServer({ version });
+            return runMakaAcpStdioServer({
+                workspaceRoot: dataRoots.workspaceRoot,
+                clientDataRoot: dataRoots.clientDataRoot,
+                version,
+            });
         }
         case 'runtime-host-serve': {
             const { runRuntimeHostServiceCli } = await import('./runtime-host-service-command.js');
@@ -591,6 +596,14 @@ export async function runMakaCli(argv = process.argv.slice(2), options = RELEASE
                 currentCredentialFingerprint: command.currentCredentialFingerprint,
             });
         }
+        case 'runtime-host-access-connection-code': {
+            const { runRuntimeHostAccessConnectionCodeCli } = await import('./runtime-host-access-command.js');
+            return runRuntimeHostAccessConnectionCodeCli({
+                rootPath: command.rootPath ?? dataRoots.workspaceRoot,
+                ...(command.expectedRootId ? { expectedRootId: command.expectedRootId } : {}),
+                ...(command.name ? { name: command.name } : {}),
+            }, command.framed);
+        }
         case 'runtime-host-access-list': {
             const { runRuntimeHostAccessListCli } = await import('./runtime-host-access-command.js');
             return runRuntimeHostAccessListCli({

package/dist/pi-transcript.js

@@ -1383,7 +1383,7 @@ function formatElapsedDuration(elapsedMs) {
     return parts.join(' ');
 }
 const TUI_PENDING_QUEUE_COPY = resolveUiMessageCatalog(defineUiMessageCatalog()(TUI_COPY_RESOURCES['pending-queue']));
-export function renderMakaPiPendingQueue(state, width, platform = process.platform, locale = 'en') {
+export function renderMakaPiPendingQueue(state, width, platform, locale) {
     if (state.steering.length === 0 && state.followup.length === 0) {
         return [];
     }

package/dist/pi-tui-layout.js

@@ -92,7 +92,7 @@ export class MakaActivityStripComponent {
 export class MakaPendingQueueComponent {
     state;
     locale;
-    constructor(state, locale = 'en') {
+    constructor(state, locale) {
         this.state = state;
         this.locale = locale;
     }

package/dist/pi-tui-mcp-status.js

@@ -617,7 +617,7 @@ function actionNotice(result, locale) {
     };
 }
 function resultCopy(locale, code) {
-    return MCP_STATUS_COPY[locale].editor.results[code] ?? code;
+    return MCP_STATUS_COPY[locale].editor.results[code];
 }
 function confirmAddDocument(draft, locale) {
     const editor = MCP_STATUS_COPY[locale].editor;

package/dist/pi-tui-runner.js

@@ -2797,7 +2797,7 @@ export async function runMakaPiTui(input) {
                     state.entries.push({
                         kind: 'notice',
                         level: 'error',
-                        text: 'Usage: /copy [all]',
+                        text: copyCopy.usage,
                     });
                     requestRender();
                     return;

package/dist/runtime-host-access-command.js

@@ -16,8 +16,10 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { randomUUID } from 'node:crypto';
+import { hostname } from 'node:os';
 import { truncateUtf8 } from '@maka/core/diagnostic-log';
-import { connectExistingRuntimeHost, consumeAccessCredentialDelivery, } from '@maka/runtime-host/client';
+import { connectExistingRuntimeHost, consumeAccessCredentialDelivery, issueRuntimeHostOwnerConnectionCode, REMOTE_DESKTOP_OWNER_ACCESS_POLICY, } from '@maka/runtime-host/client';
 import { isOperationKey, REMOTE_OWNER_OPERATION_GRANTS, RUNTIME_HOST_PROTOCOL_VERSION, } from '@maka/runtime-host/protocol';
 import { readRuntimeHostAccessCredentialMetadata, } from '@maka/runtime-host/server';
 import { encodeRuntimeHostAccessManagementFrame, RUNTIME_HOST_ACCESS_MANAGEMENT_ERROR_MESSAGE_MAX_BYTES, } from '@maka/runtime-host/operator';
@@ -63,6 +65,36 @@ export async function runRuntimeHostAccessListCli(options, framed = false) {
         return 1;
     }
 }
+export async function runRuntimeHostAccessConnectionCodeCli(options, framed = false) {
+    let connection;
+    try {
+        connection = await connectLocalOwner(options.rootPath, options.expectedRootId);
+        const connectionCode = await issueRuntimeHostOwnerConnectionCode({
+            rootPath: options.rootPath,
+            name: options.name?.trim() || truncateUtf8(hostname(), 128) || 'Runtime Host',
+            principalId: `connection-code:${randomUUID()}`,
+            client: connection,
+        });
+        process.stdout.write(framed
+            ? encodeRuntimeHostAccessManagementFrame({
+                schemaVersion: 1,
+                kind: 'result',
+                action: 'connection-code',
+                connectionCode,
+            })
+            : `${connectionCode}\n`);
+        return 0;
+    }
+    catch (error) {
+        if (!framed)
+            throw error;
+        writeAccessManagementError('connection-code', error);
+        return 1;
+    }
+    finally {
+        await connection?.close();
+    }
+}
 export async function runRuntimeHostAccessPrepareCli(options) {
     try {
         const before = await listRuntimeHostAccessCredentials(options);
@@ -146,12 +178,13 @@ export function resolveRuntimeHostAccessIssue(options) {
             canUseHostPaths: options.canUseHostPaths,
         };
     }
-    const canPublishClientCapabilities = options.preset === 'desktop-client';
-    const operationGrants = REMOTE_OWNER_OPERATION_GRANTS.filter((operation) => canPublishClientCapabilities || !CLIENT_CAPABILITY_PUBLICATION_OPERATIONS.has(operation));
+    if (options.preset === 'desktop-client')
+        return REMOTE_DESKTOP_OWNER_ACCESS_POLICY;
+    const operationGrants = REMOTE_OWNER_OPERATION_GRANTS.filter((operation) => !CLIENT_CAPABILITY_PUBLICATION_OPERATIONS.has(operation));
     return {
         principalKind: 'remote_owner',
         operationGrants,
-        canPublishClientCapabilities,
+        canPublishClientCapabilities: false,
         canUseHostPaths: false,
     };
 }

package/dist/runtime-host-capability-provider-command.js

@@ -20,7 +20,7 @@ import { createHash } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
-import { createCredentialMcpOAuthStorage, McpClientManager } from '@maka/mcp';
+import { createCredentialMcpOAuthStorage, formatMcpDiagnosticText, McpClientManager, } from '@maka/mcp';
 import { createFileCredentialStore } from '@maka/storage/credential-store';
 import { normalizeMcpConfig } from '@maka/storage/mcp-config-store';
 import { connectRemoteRuntimeHost, loadOrCreateRuntimeHostClientInstanceId, remoteRuntimeHostUnavailableError, RuntimeHostPermanentReconnectError, startRuntimeHostCapabilityProviderService, } from '@maka/runtime-host/client';
@@ -93,7 +93,7 @@ export async function runRuntimeHostCapabilityProviderCli(options) {
         });
         await runRuntimeHostProcessLifecycle(service, {
             onReady: () => {
-                process.stdout.write(`Runtime Host capability provider is connected (${manager.toolSnapshot().tools.length} MCP tools)\n`);
+                process.stdout.write(formatRuntimeHostCapabilityProviderReadyMessage(manager));
             },
         });
         return 0;
@@ -142,6 +142,20 @@ async function connectRemoteCapabilityProvider(input) {
     throw new Error('Runtime Host is draining');
 }
 export { createMcpCapabilityProvider } from './mcp-capability-provider.js';
+export function formatRuntimeHostCapabilityProviderReadyMessage(manager) {
+    const failures = manager
+        .statuses()
+        .filter((status) => status.state === 'error' ||
+        status.state === 'disconnected' ||
+        status.state === 'needs-auth')
+        .sort((left, right) => left.serverId.localeCompare(right.serverId));
+    const failureSummary = failures.length === 0
+        ? ''
+        : `; ${failures.length} ${failures.length === 1 ? 'server' : 'servers'} failed: ${failures
+            .map((status) => `${formatMcpDiagnosticText(status.serverId)} — ${status.error ?? status.state}`)
+            .join('; ')}`;
+    return `Runtime Host capability provider is connected (${manager.toolSnapshot().tools.length} MCP tools${failureSummary})\n`;
+}
 function reportRefreshFailure(error) {
     const message = error instanceof Error ? error.message : String(error);
     process.stderr.write(`Runtime Host capability publication refresh failed: ${message}\n`);