maka-agent 0.2.0-dev.3.20260830 → 0.2.0-dev.31.20260913

package/dist/acp/stdio-server.js

@@ -18,8 +18,32 @@
  */
 import { Readable, Writable } from 'node:stream';
 import { ndJsonStream } from '@agentclientprotocol/sdk';
+import { isRuntimeHostReconnectingConnection, } from '@maka/runtime-host/client';
 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,
+            });
+            const connection = context.connection;
+            if (!isRuntimeHostReconnectingConnection(connection)) {
+                await context.close().catch(() => undefined);
+                throw new Error('ACP requires a reconnecting Runtime Host connection');
+            }
+            return {
+                reconnecting: true,
+                request: connection.request.bind(connection),
+                openSessionSubscription: connection.openSessionSubscription.bind(connection),
+                openSessionSubscriptionOnce: connection.openSessionSubscriptionOnce.bind(connection),
+                close: () => context.close(),
+            };
+        },
+    });
     const stdin = dependencies.stdin ?? process.stdin;
     const stdout = dependencies.stdout ?? process.stdout;
     let stdioError;
@@ -30,7 +54,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 +67,6 @@ export async function runMakaAcpStdioServer(input, dependencies = {}) {
     finally {
         stdin.off('error', recordStdioError);
         stdout.off('error', recordStdioError);
+        await sessionRegistry.dispose();
     }
 }

package/dist/activation-command.js

@@ -393,8 +393,7 @@ export async function runMakaActivationCli(argv, overrides = {}) {
     if (invocation?.failure?.class === 'permission_denied') {
         return finish('blocked', 'permission_denied', undefined, 'grant_permission');
     }
-    if ((streamBoundaryFailure && invocation?.sandboxBoundary !== 'recovered') ||
-        invocation?.sandboxBoundary === 'unresolved') {
+    if (streamBoundaryFailure || invocation?.sandboxBoundary === 'unresolved') {
         return finish('blocked', 'permission_required', undefined, 'grant_permission');
     }
     if (!invocation)

package/dist/cli-core.js

@@ -20,8 +20,9 @@ import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { deriveMakaDataRoots, resolveMakaDataRoots } from './workspace-root.js';
-import { configureRuntimeHostPeerClient, resolveRuntimeHostPeerNativePath, } from './runtime-host-peer-artifact.js';
+import { configureRuntimeHostPeerClient, resolveRuntimeHostNativePath, } from './runtime-host-peer-artifact.js';
 import { parseRuntimeHostCommand, parseRuntimeHostInstalledUpdateCommand, } from './runtime-host-cli.js';
+import { sessionBundleHelpText } from './runtime-host-help.js';
 import { resolveCliUiLocale } from './cli-ui-locale.js';
 export const RELEASE_MAKA_CLI_LAUNCH_OPTIONS = {
     dataProfileName: 'Maka',
@@ -52,12 +53,17 @@ export function parseMakaCliArgs(argv, version, cliCommand = RELEASE_MAKA_CLI_LA
         return { kind: 'run', args: argv.slice(1) };
     if (first === 'activate')
         return { kind: 'activate', args: argv.slice(1) };
+    if (first === 'session-export' || first === 'session-import') {
+        return argv[1] === '--help' || argv[1] === '-h'
+            ? { kind: 'help', text: sessionBundleHelpText(cliCommand, first) }
+            : { kind: first, args: argv.slice(1) };
+    }
     if (first === 'eval')
         return { kind: 'eval', args: argv.slice(1) };
     if (first === 'update')
-        return parseRuntimeHostInstalledUpdateCommand(argv.slice(1));
+        return parseRuntimeHostInstalledUpdateCommand(argv.slice(1), cliCommand);
     if (first === 'runtime-host')
-        return parseRuntimeHostCommand(argv.slice(1));
+        return parseRuntimeHostCommand(argv.slice(1), cliCommand);
     return {
         kind: 'error',
         message: `Unexpected argument: ${first ?? ''}`,
@@ -93,41 +99,23 @@ function helpText(cliCommand) {
         'Launches the Maka terminal UI in the current working directory.',
         '',
         'Commands:',
-        `  ${cliCommand}              Start the TUI`,
-        `  ${cliCommand} --acp      Serve ACP v1 over stdio (initialize only; session support in progress)`,
-        `  ${cliCommand} run ...      Run one non-interactive model turn`,
-        `  ${cliCommand} activate ... Run one Cloud Session activation and emit JSONL`,
-        `  ${cliCommand} -p ...       Alias for ${cliCommand} run`,
-        `  ${cliCommand} eval ...     Run one declarative multi-arm experiment`,
-        `  ${cliCommand} update --target <latest|next|version>  Update this npm-global CLI and its local Runtime Host`,
-        `  ${cliCommand} runtime-host serve [options]  Run a Runtime Host service`,
-        `  ${cliCommand} runtime-host activate --framed --root-id <id>`,
-        `  ${cliCommand} runtime-host setup --principal <id> --preset <desktop-client|terminal-client> [options]`,
-        `  ${cliCommand} runtime-host service install [options]`,
-        `  ${cliCommand} runtime-host service configure (--project-root <label>=<path> ... | --no-project-roots) --expected-config-fingerprint <sha256:...> --expected-service-id <id> --expected-root-path <path> --expected-root-id <id> [--allow-interrupt-active-tasks]`,
-        `  ${cliCommand} runtime-host service status|start|stop|restart|logs [--json]`,
-        `  ${cliCommand} runtime-host service uninstall --expected-service-id <id> --expected-root-path <path> --expected-root-id <id> [--allow-interrupt-active-tasks]`,
-        `  ${cliCommand} runtime-host service peer enable|disable|status|rotate|descriptor [options]`,
-        `  ${cliCommand} runtime-host service mesh status|create|invite|join|remove|leave|close|reconcile [options]`,
-        `  ${cliCommand} runtime-host service retire --expected-service-id <id> --expected-root-path <path> --expected-root-id <id> [--allow-interrupt-active-tasks]`,
-        `  ${cliCommand} runtime-host service check-update --target <latest|next|version> [--json]`,
-        `  ${cliCommand} runtime-host service update [--target <latest|next|version>] --expected-service-id <id> --expected-root-path <path> --expected-root-id <id> [--allow-interrupt-active-tasks]`,
-        `  ${cliCommand} runtime-host service update-policy [--target <manual|latest|next|version>] [--json]`,
-        `  ${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 list`,
-        `  ${cliCommand} runtime-host access issue --kind capability-provider --principal <id>`,
-        `  ${cliCommand} runtime-host access revoke --credential <id>`,
-        `  ${cliCommand} runtime-host project list [--root <path>]`,
-        `  ${cliCommand} runtime-host project add <path> [--prefer] [--root <path>]`,
-        `  ${cliCommand} runtime-host profile list`,
-        `  ${cliCommand} runtime-host profile set --id <id> --name <name> --tls-url <wss-url> --expected-root <root-id> [--credential-env <name>]`,
-        `  ${cliCommand} runtime-host profile set --id <id> --name <name> --ssh-destination <user@host> --ssh-remote-port <port> --expected-root <root-id> [--ssh-port <port>] [--credential-env <name>]`,
-        `  ${cliCommand} runtime-host profile set --id <id> --name <name> --plaintext-url <ws-url> --acknowledge-plaintext --expected-root <root-id> [--credential-env <name>]`,
-        `  ${cliCommand} runtime-host profile set --id <id> --name <name> --peer-id <peer-id> --peer-route <multiaddr> --expected-root <root-id> [--credential-env <name>]`,
-        `  ${cliCommand} runtime-host profile remove --id <id>`,
-        `  ${cliCommand} runtime-host capability-provider serve --url <ws-url> --mcp-config <path> --expected-root <root-id>`,
+        ...[
+            ['', 'Start the TUI'],
+            ['--acp', 'Serve ACP v1 over stdio (sessions, prompts, streaming, cancellation)'],
+            ['run ...', 'Run one non-interactive model turn'],
+            ['-p ...', `Alias for ${cliCommand} run`],
+            ['activate ...', 'Run one Cloud Session activation and emit JSONL'],
+            ['eval ...', 'Run one declarative multi-arm experiment'],
+            ['session-export ...', 'Write a Session bundle to a file'],
+            ['session-import ...', 'Read a Session bundle back into a workspace'],
+            ['update ...', 'Update this npm-global CLI and its local Runtime Host'],
+            ['runtime-host ...', 'Serve and manage a Runtime Host'],
+        ].map(([name, summary], _index, entries) => {
+            // A custom launcher ("npm run cli:dev --") is far wider than `maka`, so the
+            // column is measured, never assumed.
+            const width = Math.max(...entries.map(([other]) => `${cliCommand} ${other}`.trimEnd().length));
+            return `  ${`${cliCommand} ${name}`.trimEnd().padEnd(width + 2)}${summary}`;
+        }),
         '',
         'Options:',
         '  -h, --help        Show help',
@@ -136,67 +124,8 @@ function helpText(cliCommand) {
         '  --resume <id> --cwd <path>  Reopen a session after its directory moved',
         '  --host <profile-id>     Connect the TUI to a saved Runtime Host profile',
         '  --project <project-id>  Select an existing Project on a remote Host',
-        '  MAKA_RUNTIME_HOST_ACCESS_CREDENTIAL  Access credential used by runtime-host profile set',
-        '',
-        'Runtime Host serve options:',
-        '  --root <path>                 Select the canonical data root',
-        '  --project-root <label>=<path> Publish an absolute project directory root (repeatable)',
-        '  --no-project-roots            Disable remote project browsing and registration',
-        '  --websocket-port <port>       Enable an authenticated WebSocket listener',
-        '  --websocket-host <host>       Bind host (default: 127.0.0.1)',
-        '  --websocket-path <path>       Upgrade path (default: /runtime-host)',
-        '  --tls-certificate <path>      TLS certificate for WSS',
-        '  --tls-private-key <path>      TLS private key for WSS',
-        '  --allow-insecure-remote       Allow plaintext WebSocket access beyond loopback',
-        '  --allow-origin <origin>       Allow one browser Origin (repeatable)',
-        '  --peer-native-path <path>     Load the experimental direct-peer native module',
-        '  --peer-key <path>             Persist the direct-peer transport identity',
-        '  --peer-id <id>                Require an existing direct-peer transport identity',
-        '  --peer-listen <multiaddr>     Listen on a direct-peer address (repeatable)',
-        '  --peer-coordination-relay <multiaddr>  Use a DCUtR coordination relay (repeatable)',
-        '  --json                        Emit one machine-readable ready event',
-        '',
-        'Managed Runtime Host service install options (Linux or macOS):',
-        '  --root <path>                 Select the canonical data root',
-        '  --project-root <label>=<path> Publish an absolute directory root (repeatable)',
-        '  --no-project-roots            Disable remote project browsing and registration',
-        '  --websocket-port <port>       Persist a loopback port (chosen automatically by default)',
-        '  --websocket-path <path>       Persist the upgrade path (default: /runtime-host)',
-        '  --json                        Emit a machine-readable result',
-        '',
-        'Managed Runtime Host setup options (Linux or macOS):',
-        '  --principal <id>              Stable Client pairing identity',
-        '  --preset <name>               Pair a desktop-client or terminal-client',
-        '  --root <path>                 Select the canonical data root',
-        '  --project-root <label>=<path> Publish an absolute directory root (repeatable)',
-        '  --no-project-roots            Disable remote project browsing and registration',
-        '  --websocket-port <port>       Persist a loopback port (chosen automatically by default)',
-        '  --websocket-path <path>       Persist the upgrade path (default: /runtime-host)',
-        '  --json                        Emit framed machine-readable progress and result records',
         '',
-        'Managed Runtime Host direct-peer options:',
-        '  --listen <multiaddr>          Persist a listener address (repeatable)',
-        '  --coordination-relay <addr>   Prefer a Circuit Relay v2 address (repeatable)',
-        '  --clear-coordination-relays   Remove every manually configured relay',
-        '  --automatic-relay-discovery   Enable best-effort public relay discovery',
-        '  --no-automatic-relay-discovery  Disable public discovery and retain manual relays',
-        '',
-        'Runtime Host access issue options:',
-        '  --root <path>                 Select the canonical data root',
-        '  --kind <kind>                 remote-owner or capability-provider',
-        '  --principal <id>              Name the authenticated Client principal',
-        '  --grant <operation>           Grant one exact operation (repeatable)',
-        '  --preset <name>               Grant the desktop-client or terminal-client operation set',
-        '  --publish-client-capabilities Allow Client Capability publication',
-        '  --allow-host-paths            Allow operations that submit Host paths',
-        '  --capability-owner-credential <id>  Bind a provider to one Client-bound owner credential',
-        '',
-        'Runtime Host capability provider options:',
-        '  --url <ws-url>                Connect to an authenticated Runtime Host WebSocket',
-        '  --mcp-config <path>           Publish tools from an MCP configuration file',
-        '  --expected-root <root-id>     Pin the canonical Runtime Host root identity',
-        '  --credential-env <name>       Read the access credential from this environment variable',
-        '  --client-identity <path>      Persist the provider Client instance identity here',
+        `Run \`${cliCommand} <command> --help\` for a command's own options.`,
     ].join('\n');
 }
 export async function runMakaCli(argv = process.argv.slice(2), options = RELEASE_MAKA_CLI_LAUNCH_OPTIONS) {
@@ -235,6 +164,14 @@ export async function runMakaCli(argv = process.argv.slice(2), options = RELEASE
             const { runMakaActivationCli } = await import('./activation-command.js');
             return runMakaActivationCli(command.args);
         }
+        case 'session-export': {
+            const { runMakaSessionExportCli } = await import('./session-export-command.js');
+            return runMakaSessionExportCli(command.args);
+        }
+        case 'session-import': {
+            const { runMakaSessionImportCli } = await import('./session-import-command.js');
+            return runMakaSessionImportCli(command.args);
+        }
         case 'eval': {
             const { configureInstalledEvalBundle } = await import('./eval-bundle-path.js');
             configureInstalledEvalBundle();
@@ -243,15 +180,23 @@ 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');
             if (command.managedDeployment) {
-                const { resolveRuntimeHostManagedDeployment, resolveRuntimeHostNpmDeploymentLayout } = await import('@maka/runtime-host/operator');
+                const { resolveRuntimeHostManagedDeployment, resolveRuntimeHostNpmDeploymentLayout, resolveRuntimeHostWebRtcStunUrls, } = await import('@maka/runtime-host/operator');
                 const { config } = await resolveRuntimeHostManagedDeployment(command.managedDeployment.rootId);
                 const peer = config.listeners.directPeer?.enabled ? config.listeners.directPeer : undefined;
                 const packageLayout = resolveRuntimeHostNpmDeploymentLayout(config.deploymentRoot, config.launch.package.integrity);
+                if (process.platform === 'win32') {
+                    const { ownWindowsRuntimeHostProcessTree } = await import('./runtime-host-windows-service.js');
+                    await ownWindowsRuntimeHostProcessTree(packageLayout.cliPath);
+                }
                 return runRuntimeHostServiceCli({
                     rootPath: config.root.path,
                     json: command.json,
@@ -264,12 +209,13 @@ export async function runMakaCli(argv = process.argv.slice(2), options = RELEASE
                     ...(peer
                         ? {
                             peer: {
-                                nativePath: await resolveRuntimeHostPeerNativePath(packageLayout.cliPath),
+                                nativePath: await resolveRuntimeHostNativePath(packageLayout.cliPath),
                                 keyPath: peer.keyPath,
                                 expectedPeerId: peer.peerId,
                                 listenAddresses: peer.listenAddresses,
                                 coordinationRelays: peer.coordinationRelays,
                                 automaticRelayDiscovery: peer.automaticRelayDiscovery,
+                                webRtcStunUrls: resolveRuntimeHostWebRtcStunUrls(peer.webRtcStunPolicy),
                                 meshDataRoot: join(config.deploymentRoot, 'peer-mesh'),
                             },
                         }
@@ -321,6 +267,7 @@ export async function runMakaCli(argv = process.argv.slice(2), options = RELEASE
                         : { compatibility: command.targetCompatibility }),
                 },
                 allowInterruptActiveTasks: command.allowInterruptActiveTasks,
+                ...(command.expectedSource ? { expectedSource: command.expectedSource } : {}),
             });
         }
         case 'runtime-host-local-update-activate': {
@@ -340,6 +287,17 @@ export async function runMakaCli(argv = process.argv.slice(2), options = RELEASE
                 ...(command.awaitCoordinatorCommit ? { inheritableAuthorityLeaseFd: 4 } : {}),
             });
         }
+        case 'runtime-host-local-source-retire': {
+            const { runRuntimeHostLocalSourceRetirement } = await import('./runtime-host-local-source-retirement.js');
+            return runRuntimeHostLocalSourceRetirement({
+                rootPath: command.rootPath,
+                expectedRootId: command.expectedRootId,
+                expectedHostEpoch: command.expectedHostEpoch,
+                activeWorkPolicy: command.allowInterruptActiveTasks
+                    ? 'interrupt_active_work'
+                    : 'refuse_active_work',
+            });
+        }
         case 'runtime-host-setup': {
             const { runRuntimeHostSetupCli } = await import('./runtime-host-setup-command.js');
             const { RUNTIME_HOST_SETUP_SOURCE_PACKAGE_INTEGRITY_ENV } = await import('@maka/runtime-host/operator');
@@ -357,6 +315,8 @@ export async function runMakaCli(argv = process.argv.slice(2), options = RELEASE
                 bindPairingToClient: command.bindPairingToClient,
                 ...(command.repairRootAfterRemount ? { repairRootAfterRemount: true } : {}),
                 updateExisting: command.updateExisting,
+                reuseExistingEnvironment: command.reuseExistingEnvironment,
+                allowInterruptActiveTasks: command.allowInterruptActiveTasks,
                 ...(command.rootPath ? { rootPath: command.rootPath } : {}),
                 ...(command.projectDirectoryRoots
                     ? { projectDirectoryRoots: command.projectDirectoryRoots }
@@ -394,6 +354,7 @@ export async function runMakaCli(argv = process.argv.slice(2), options = RELEASE
                 ...(command.expectedConfigFingerprint
                     ? { expectedConfigFingerprint: command.expectedConfigFingerprint }
                     : {}),
+                ...(command.expectedHost ? { expectedHost: command.expectedHost } : {}),
                 ...(command.retainManagedDeployment ? { retainManagedDeployment: true } : {}),
                 ...(command.allowInterruptActiveTasks ? { allowInterruptActiveTasks: true } : {}),
             });
@@ -419,6 +380,8 @@ export async function runMakaCli(argv = process.argv.slice(2), options = RELEASE
                     ? {}
                     : { automaticRelayDiscovery: command.automaticRelayDiscovery }),
                 ...(command.relayDiscoveryStatus ? { relayDiscoveryStatus: true } : {}),
+                ...(command.webRtcStunPolicy ? { webRtcStunPolicy: command.webRtcStunPolicy } : {}),
+                ...(command.webRtcStunStatus ? { webRtcStunStatus: true } : {}),
                 ...(command.expectedTarget ? { expectedTarget: command.expectedTarget } : {}),
                 ...(command.allowInterruptActiveTasks ? { allowInterruptActiveTasks: true } : {}),
             });
@@ -435,6 +398,7 @@ export async function runMakaCli(argv = process.argv.slice(2), options = RELEASE
                 expectedTarget: command.expectedTarget,
                 ...(command.meshId !== undefined ? { meshId: command.meshId } : {}),
                 ...(command.peerId ? { peerId: command.peerId } : {}),
+                ...(command.displayName !== undefined ? { displayName: command.displayName } : {}),
             });
         }
         case 'runtime-host-service-update': {
@@ -452,11 +416,18 @@ export async function runMakaCli(argv = process.argv.slice(2), options = RELEASE
                     defaultRootPath: serviceDataRoots.workspaceRoot,
                     selector: command.selector,
                     expectedTarget: command.expectedTarget,
+                    ...(command.expectedSourceVersion
+                        ? { expectedSourceVersion: command.expectedSourceVersion }
+                        : {}),
                     ...(command.expectedHost ? { expectedHost: command.expectedHost } : {}),
+                    ...(command.expectedConfigFingerprint
+                        ? { expectedConfigFingerprint: command.expectedConfigFingerprint }
+                        : {}),
                     ...(command.managedRootId ? { managedRootId: command.managedRootId } : {}),
                     ...(command.operatorDeploymentId
                         ? { operatorDeploymentId: command.operatorDeploymentId }
                         : {}),
+                    ...(command.allowManualUpdate ? { allowManualUpdate: true } : {}),
                     ...(command.allowInterruptActiveTasks ? { allowInterruptActiveTasks: true } : {}),
                 });
             }
@@ -469,7 +440,13 @@ export async function runMakaCli(argv = process.argv.slice(2), options = RELEASE
                 ...(sourcePackageIntegrity ? { sourcePackageIntegrity } : {}),
                 version,
                 expectedTarget: command.expectedTarget,
+                ...(command.expectedSourceVersion
+                    ? { expectedSourceVersion: command.expectedSourceVersion }
+                    : {}),
                 ...(command.expectedHost ? { expectedHost: command.expectedHost } : {}),
+                ...(command.expectedConfigFingerprint
+                    ? { expectedConfigFingerprint: command.expectedConfigFingerprint }
+                    : {}),
                 ...(command.managedRootId ? { managedRootId: command.managedRootId } : {}),
                 ...(command.operatorDeploymentId
                     ? { operatorDeploymentId: command.operatorDeploymentId }
@@ -567,6 +544,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({
@@ -600,6 +585,18 @@ export async function runMakaCli(argv = process.argv.slice(2), options = RELEASE
                     prefer: command.prefer,
                 });
         }
+        case 'runtime-host-plugin': {
+            const { runRuntimeHostPluginCli } = await import('./runtime-host-plugin-command.js');
+            return runRuntimeHostPluginCli({
+                rootPath: command.rootPath ?? dataRoots.workspaceRoot,
+                action: command.action,
+                ...(command.subject ? { subject: command.subject } : {}),
+                ...(command.targetPath ? { targetPath: command.targetPath } : {}),
+                ...(command.rootId ? { rootId: command.rootId } : {}),
+                ...(command.cursor === undefined ? {} : { cursor: command.cursor }),
+                ...(command.limit === undefined ? {} : { limit: command.limit }),
+            });
+        }
         case 'runtime-host-capability-provider-serve': {
             const { runRuntimeHostCapabilityProviderCli } = await import('./runtime-host-capability-provider-command.js');
             return runRuntimeHostCapabilityProviderCli({
@@ -633,7 +630,7 @@ export async function runMakaCli(argv = process.argv.slice(2), options = RELEASE
                     id: command.id,
                     name: command.name,
                     distribution: command.distribution,
-                    operatorPath: command.operatorPath,
+                    operator: command.operator,
                     expectedRootId: command.expectedRootId,
                 }, {}, profileOptions);
             }

package/dist/cli-ui-locale.js

@@ -20,11 +20,16 @@ import { isUiLocalePreference, resolveSystemUiLocale, resolveUiLocale, } from '@
 /** Resolve the interactive TUI locale without changing the top-level CLI grammar. */
 export function resolveCliUiLocale(environment) {
     const rawPreference = environment.MAKA_LOCALE?.trim();
-    const preference = rawPreference ? rawPreference.toLowerCase() : 'auto';
+    const normalizedPreference = rawPreference?.replaceAll('_', '-').toLowerCase() || 'auto';
+    const preference = normalizedPreference === 'zh' || normalizedPreference === 'zh-cn'
+        ? 'zh-CN'
+        : normalizedPreference === 'zh-tw'
+            ? 'zh-TW'
+            : normalizedPreference;
     if (!isUiLocalePreference(preference)) {
         return {
             ok: false,
-            message: `Invalid MAKA_LOCALE ${JSON.stringify(rawPreference)}. Expected zh, en, or auto.`,
+            message: `Invalid MAKA_LOCALE ${JSON.stringify(rawPreference)}. Expected zh-CN, zh-TW, en, or auto.`,
         };
     }
     // POSIX locale variables are authorities, not a preference list. Once a

package/dist/eval-bundle-path.js

@@ -23,7 +23,7 @@ export function configureInstalledEvalBundle(environment = process.env, packageR
     if (Object.hasOwn(environment, MAKA_EVAL_BUNDLE_ENV))
         return;
     try {
-        if (!statSync(resolve(packageRoot, 'packages/eval')).isDirectory())
+        if (!statSync(resolve(packageRoot, 'node_modules/@maka/eval')).isDirectory())
             return;
     }
     catch {

package/dist/mcp-capability-provider.js

@@ -17,6 +17,7 @@
  * under the License.
  */
 import { createHash } from 'node:crypto';
+import { clientCapabilityEntityId } from '@maka/runtime-host/client-capability-entity-id';
 import { CLIENT_CAPABILITY_MAX_TOOLS, CLIENT_CAPABILITY_MAX_TOOLS_PER_OFFER, decodeClientCapabilityReplaceInput, } from '@maka/runtime-host/protocol';
 const CAPABILITY_VERSION = '0';
 export function createMcpCapabilityProvider(manager) {
@@ -32,7 +33,7 @@ export function createMcpCapabilityProvider(manager) {
     const projectedIdentities = new Set();
     const projected = [];
     for (const source of tools) {
-        const descriptor = projectMcpTool(source.descriptor, capabilityEntityId(source.descriptor.serverId));
+        const descriptor = projectMcpTool(source.descriptor, clientCapabilityEntityId(source.descriptor.serverId));
         const identity = `${descriptor.serverId}\0${descriptor.name}`;
         if (projectedIdentities.has(identity)) {
             throw new Error('MCP tools collide after Client Capability identity normalization');
@@ -71,27 +72,23 @@ export function createMcpCapabilityProvider(manager) {
             const binding = bindings.get(capabilityBindingKey(frame.offerId, frame.serverId, frame.toolName));
             if (!binding)
                 throw new Error('MCP capability is not part of the published snapshot');
-            await options.accept();
-            return projectMcpResult(await manager.callTool(binding, frame.arguments, { signal: options.signal }));
+            await options.accept({ kind: 'none' });
+            return projectMcpResult(await manager.callTool(binding, frame.arguments, {
+                signal: options.signal,
+                requestInteraction: options.requestInteraction,
+            }));
         },
     };
 }
 function projectMcpTool(tool, wireServerId) {
     return {
         serverId: wireServerId,
-        name: capabilityEntityId(tool.name),
+        name: clientCapabilityEntityId(tool.name),
         ...(tool.description ? { description: tool.description } : {}),
         inputSchema: structuredClone(tool.inputSchema),
         ...(tool.annotations ? { annotations: { ...tool.annotations } } : {}),
     };
 }
-function capabilityEntityId(value) {
-    if (/^[A-Za-z0-9_-]{1,128}$/u.test(value))
-        return value;
-    const label = value.replace(/[^A-Za-z0-9_-]+/gu, '_').slice(0, 103) || 'mcp';
-    const digest = createHash('sha256').update(value).digest('hex').slice(0, 24);
-    return `${label}_${digest}`;
-}
 function projectMcpResult(result) {
     return {
         content: result.content.map((block) => structuredClone(block)),

package/dist/onboarding-catalog.js

@@ -16,7 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { CATALOG_PROVIDER_TYPES, PROVIDER_DEFAULTS, providerAuthSupportsApiKey, } from '@maka/core/llm-connections';
+import { CATALOG_PROVIDER_TYPES, PROVIDER_REGISTRY, providerAuthSupportsApiKey, } from '@maka/core/llm-connections';
 export function listApiKeyOnboardableProviders() {
     // Custom relays have no built-in base URL and stay listed: `requiresBaseUrl`
     // tells the wizard to collect an endpoint before the API key. The original
@@ -28,16 +28,15 @@ export function listApiKeyOnboardableProviders() {
     return CATALOG_PROVIDER_TYPES.filter((providerType) => {
         if (!providerAuthSupportsApiKey(providerType))
             return false;
-        const definition = PROVIDER_DEFAULTS[providerType];
+        const definition = PROVIDER_REGISTRY[providerType];
         return Boolean(definition.baseUrl) || definition.category === 'custom';
     }).map((providerType) => {
-        const definition = PROVIDER_DEFAULTS[providerType];
+        const definition = PROVIDER_REGISTRY[providerType];
         return {
             providerType,
             label: definition.label,
-            authKind: definition.authKind,
             requiresBaseUrl: !definition.baseUrl,
-            fallbackModels: definition.fallbackModels,
+            setupMethod: 'api_key',
         };
     });
 }

package/dist/pi-transcript-tools.js

@@ -267,6 +267,12 @@ function compactToolSummary(entry) {
         isReadBodyResult(result)) {
         return { text: linesText(readBodyLineCount(text)), protect: true };
     }
+    const status = makaPiToolPresentationStatus(entry);
+    // Error-text size is not a successful read's size. Show only the outcome,
+    // including under NO_COLOR; the full reason remains in expanded details.
+    if (status === 'error' || status === 'failed' || status === 'aborted') {
+        return { text: status === 'error' ? 'failed' : status, protect: true };
+    }
     return textResultSummary(text);
 }
 function compactTerminalSummary(content) {
@@ -372,11 +378,12 @@ function readInputRef(entry) {
 }
 /** A Read using the filesystem branch. */
 function isFilesystemReadPath(entry) {
-    return readInputPath(entry) !== undefined;
+    const path = readInputPath(entry);
+    return path !== undefined && !path.startsWith('maka:');
 }
 /** A Read using the runtime-resource branch (background-task output, etc.). */
 function isRuntimeResourceRead(entry) {
-    return readInputRef(entry)?.startsWith('maka://runtime/') ?? false;
+    return (readInputPath(entry) ?? readInputRef(entry))?.startsWith('maka:') ?? false;
 }
 /**
  * True only for the result shapes a filesystem Read uses to carry actual file