maka-agent 0.2.0-dev.22.20260905 → 0.2.0-dev.24.20260907

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

@@ -26,5 +26,6 @@ export function createMakaAcpAgent(options) {
         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));
+        .onRequest(methods.agent.session.list, ({ params }) => options.sessionRegistry.list(params))
+        .onRequest(methods.agent.session.setConfigOption, ({ params }) => options.sessionRegistry.setConfigOption(params));
 }

package/dist/acp/session-configuration.js

@@ -0,0 +1,143 @@
+/*
+ * 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 { COLLABORATION_MODES } from '@maka/core/collaboration';
+import { THINKING_LEVELS } from '@maka/core/model-thinking';
+import { ORCHESTRATION_MODES } from '@maka/core/orchestration';
+import { CHAT_DEFAULT_PERMISSION_MODES } from '@maka/core/settings';
+const PERMISSION_NAMES = {
+    explore: 'Explore',
+    ask: 'Ask',
+    bypass: 'Bypass',
+};
+const THINKING_NAMES = {
+    default: 'Default',
+    off: 'Off',
+    minimal: 'Minimal',
+    low: 'Low',
+    medium: 'Medium',
+    high: 'High',
+    xhigh: 'Extra high',
+    max: 'Max',
+};
+const COLLABORATION_NAMES = {
+    agent: 'Agent',
+    plan: 'Plan',
+};
+const ORCHESTRATION_NAMES = {
+    default: 'Default',
+    swarm: 'Swarm',
+    graph: 'Graph',
+};
+const PERMISSION_SPEC = {
+    id: 'permission_mode',
+    name: 'Permission mode',
+    category: '_maka/permission_mode',
+    options: namedOptions(CHAT_DEFAULT_PERMISSION_MODES, PERMISSION_NAMES),
+};
+const THINKING_SPEC = {
+    id: 'thinking_level',
+    name: 'Thinking level',
+    category: 'thought_level',
+    options: namedOptions(['default', ...THINKING_LEVELS], THINKING_NAMES),
+};
+const COLLABORATION_SPEC = {
+    id: 'collaboration_mode',
+    name: 'Collaboration mode',
+    category: 'mode',
+    options: namedOptions(COLLABORATION_MODES, COLLABORATION_NAMES),
+};
+const ORCHESTRATION_SPEC = {
+    id: 'orchestration_mode',
+    name: 'Orchestration mode',
+    category: '_maka/orchestration_mode',
+    options: namedOptions(ORCHESTRATION_MODES, ORCHESTRATION_NAMES),
+};
+const CONFIG_SPECS = [
+    PERMISSION_SPEC,
+    THINKING_SPEC,
+    COLLABORATION_SPEC,
+    ORCHESTRATION_SPEC,
+];
+export function projectAcpSessionConfigOptions(session, thinkingLevels) {
+    return [
+        configOption(PERMISSION_SPEC, session.permissionMode),
+        ...(thinkingLevels.length === 0
+            ? []
+            : [
+                configOption({
+                    ...THINKING_SPEC,
+                    options: namedOptions(['default', ...thinkingLevels], THINKING_NAMES),
+                }, session.thinkingLevel ?? 'default'),
+            ]),
+        configOption(COLLABORATION_SPEC, session.collaborationMode),
+        configOption(ORCHESTRATION_SPEC, session.orchestrationMode),
+    ];
+}
+function namedOptions(values, names) {
+    return values.map((value) => [value, names[value]]);
+}
+function configOption(spec, currentValue) {
+    return {
+        type: 'select',
+        id: spec.id,
+        name: spec.name,
+        category: spec.category,
+        currentValue,
+        options: spec.options.map(([value, name]) => ({ value, name })),
+    };
+}
+export class AcpSessionConfigInputError extends Error {
+    field;
+    reason;
+    name = 'AcpSessionConfigInputError';
+    constructor(field, reason) {
+        super(`Invalid ACP Session configuration ${field}`);
+        this.field = field;
+        this.reason = reason;
+    }
+}
+export function validateAcpSessionConfigOptionRequest(request) {
+    const spec = CONFIG_SPECS.find(({ id }) => id === request.configId);
+    if (!spec)
+        throw new AcpSessionConfigInputError('configId', 'unsupported');
+    if (typeof request.value !== 'string')
+        throw new AcpSessionConfigInputError('value', 'invalid_type');
+    if (!spec.options.some(([value]) => value === request.value)) {
+        throw new AcpSessionConfigInputError('value', 'unsupported');
+    }
+}
+export function createAcpSessionConfigPatch(request) {
+    validateAcpSessionConfigOptionRequest(request);
+    switch (request.configId) {
+        case 'permission_mode':
+            return { permissionMode: request.value };
+        case 'thinking_level':
+            return {
+                thinkingLevel: request.value === 'default'
+                    ? null
+                    : request.value,
+            };
+        case 'collaboration_mode':
+            return { collaborationMode: request.value };
+        case 'orchestration_mode':
+            return { orchestrationMode: request.value };
+        default:
+            throw new AcpSessionConfigInputError('configId', 'unsupported');
+    }
+}

package/dist/acp/session-registry.js

@@ -20,14 +20,17 @@ 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 { readRuntimeHostConnectionCatalog, 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';
+import { RuntimeHostSessionUpdateError, requireRuntimeHostSessionProjection, updateRuntimeHostSession, } from '../runtime-host-session-update.js';
+import { AcpSessionConfigInputError, createAcpSessionConfigPatch, projectAcpSessionConfigOptions, validateAcpSessionConfigOptionRequest, } from './session-configuration.js';
 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();
+    #ownedSessionIds = new Set();
     #connection;
     #connectTask;
     #connectAbortController;
@@ -47,6 +50,19 @@ export class AcpSessionRegistry {
         this.#assertOpen('session.catalog.query');
         return this.#track(this.#list(params));
     }
+    async setConfigOption(params) {
+        this.#assertOpen('session.configuration.update');
+        if (!this.#ownedSessionIds.has(params.sessionId)) {
+            throw RequestError.invalidParams({ reason: 'unknown_session' }, 'Session is not owned by this ACP connection');
+        }
+        try {
+            validateAcpSessionConfigOptionRequest(params);
+        }
+        catch (error) {
+            throw requestErrorFromConfigInput(error);
+        }
+        return this.#track(this.#setConfigOption(params));
+    }
     dispose() {
         this.#closing = true;
         this.#connectAbortController?.abort();
@@ -56,8 +72,9 @@ export class AcpSessionRegistry {
     async #create(params) {
         const connection = await this.#getConnection('session.create');
         const sessionId = this.#newSessionId();
+        let result;
         try {
-            await connection.request('session.create', {
+            result = await connection.request('session.create', {
                 sessionId,
                 workspace: { kind: 'host_path', path: params.cwd },
                 modelTarget: { kind: 'default' },
@@ -66,7 +83,46 @@ export class AcpSessionRegistry {
         catch (error) {
             throw requestErrorFromRuntimeHost(error, 'session.create', { sessionId });
         }
-        return { sessionId };
+        let created;
+        try {
+            created = requireRuntimeHostSessionProjection(result, 'session.create');
+        }
+        catch (error) {
+            throw requestErrorFromSessionUpdate(error, 'session.create', { sessionId });
+        }
+        const configOptions = await this.#projectConfigOptions(connection, created);
+        this.#ownedSessionIds.add(sessionId);
+        return { sessionId, configOptions };
+    }
+    async #setConfigOption(params) {
+        const connection = await this.#getConnection('session.configuration.update');
+        let committed;
+        try {
+            committed = await updateRuntimeHostSession(connection, params.sessionId, (current) => connection.request('session.configuration.update', {
+                sessionId: params.sessionId,
+                expectedRevision: current.revision,
+                patch: createAcpSessionConfigPatch(params),
+            }), {
+                operation: 'session.configuration.update',
+                assertRequestAllowed: () => this.#assertOpen('session.configuration.update'),
+            });
+        }
+        catch (error) {
+            throw requestErrorFromSessionUpdate(error, 'session.configuration.update');
+        }
+        return { configOptions: await this.#projectConfigOptions(connection, committed) };
+    }
+    async #projectConfigOptions(connection, session) {
+        let catalog;
+        try {
+            catalog = await readRuntimeHostConnectionCatalog(connection);
+        }
+        catch (error) {
+            throw requestErrorFromRuntimeHost(error, 'connection.catalog.query');
+        }
+        const selectedConnection = catalog.connections.find(({ connectionId }) => connectionId === session.llmConnectionId);
+        const selectedModel = selectedConnection?.catalogEntries.find(({ id }) => id === session.model);
+        return projectAcpSessionConfigOptions(session, selectedModel?.thinkingLevels ?? []);
     }
     async #list(params) {
         const cursor = params.cursor == null ? undefined : decodeAcpSessionCursor(params.cursor);
@@ -110,6 +166,7 @@ export class AcpSessionRegistry {
         const connectionClose = this.#closeOwnedConnection();
         await Promise.allSettled([connectionClose]);
         await Promise.allSettled([...this.#inFlightOperations]);
+        this.#ownedSessionIds.clear();
     }
     #closeOwnedConnection() {
         const connection = this.#connection;
@@ -192,9 +249,38 @@ function validateNewSessionParams(params) {
         throw RequestError.invalidParams({ field: 'additionalDirectories', reason: 'unsupported' }, 'Additional directories are not supported by this ACP adapter yet');
     }
 }
+function requestErrorFromConfigInput(error) {
+    if (error instanceof AcpSessionConfigInputError) {
+        return RequestError.invalidParams({ field: error.field, reason: error.reason }, 'Invalid Session configuration option');
+    }
+    return RequestError.internalError({
+        source: 'adapter',
+        operation: 'session.configuration.update',
+        code: 'validation_failed',
+    }, 'Session configuration validation failed');
+}
+function requestErrorFromSessionUpdate(error, operation, extra = {}) {
+    if (error instanceof RequestError)
+        return error;
+    if (!(error instanceof RuntimeHostSessionUpdateError)) {
+        return requestErrorFromRuntimeHost(error, operation, extra);
+    }
+    const common = { source: 'runtime_host', operation: error.operation, ...extra };
+    switch (error.reason) {
+        case 'not_found':
+            return RequestError.invalidParams({ ...common, code: 'not_found' }, 'Runtime Host Session was not found');
+        case 'invalid_projection':
+            return RequestError.internalError({ ...common, code: 'catalog_read_failure', reason: 'invalid_projection' }, 'Runtime Host returned an invalid Session lookup');
+        case 'unsupported_session_projection':
+            return RequestError.internalError({ ...common, code: 'unsupported_session_projection' }, 'Runtime Host Session cannot be represented in ACP');
+        case 'revision_conflict':
+            return RequestError.internalError({ ...common, code: 'revision_conflict', attempts: error.attempts }, 'Session configuration kept changing');
+    }
+}
 function requestErrorFromRuntimeHost(error, operation, extra = {}) {
     const data = { ...runtimeHostErrorData(error, operation), ...extra };
-    if (error instanceof RuntimeHostOperationError && error.code === 'invalid_request') {
+    if (error instanceof RuntimeHostOperationError &&
+        (error.code === 'invalid_request' || error.code === 'not_found')) {
         return RequestError.invalidParams(data, 'Runtime Host rejected the request');
     }
     return RequestError.internalError(data, 'Runtime Host request failed');

package/dist/cli-core.js

@@ -338,6 +338,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': {
@@ -422,6 +423,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 } : {}),
             });

package/dist/pi-transcript.js

@@ -17,7 +17,7 @@
  * under the License.
  */
 import { Markdown, visibleWidth } from '@earendil-works/pi-tui';
-import { deriveTurnRecords, STEP_LIMIT_NOTICE_TEXT, } from '@maka/core/session';
+import { deriveTurnRecords, isRuntimeSystemNoteKind, STEP_LIMIT_NOTICE_TEXT, } from '@maka/core/session';
 import { providerRetryDisplaySeconds } from '@maka/core/provider-retry-countdown';
 import { defineUiMessageCatalog, resolveUiMessageCatalog, } from '@maka/core/ui-locale';
 import { TUI_COPY_RESOURCES } from './tui-copy-catalog.js';
@@ -931,14 +931,11 @@ function tokenDelta(before, after) {
     return Math.max(0, before - after);
 }
 function systemNoteText(message) {
+    // Retired kinds are still decoded off legacy transcript rows, and none of
+    // them ever had a line here worth reading.
+    if (!isRuntimeSystemNoteKind(message.kind))
+        return undefined;
     switch (message.kind) {
-        case 'session_start':
-        case 'session_resume':
-            return undefined;
-        case 'mode_change':
-            return 'Permission mode changed.';
-        case 'model_change':
-            return 'Model changed.';
         case 'context_compacted':
             return 'Context compacted to keep this task within the model window.';
         case 'context_compaction_failed_open':
@@ -984,10 +981,6 @@ function systemNoteText(message) {
         }
         case 'step_limit':
             return STEP_LIMIT_NOTICE_TEXT;
-        case 'error':
-            return 'Session recorded an error.';
-        case 'abort':
-            return 'Session was stopped.';
     }
 }
 export function renderMakaPiTranscript(state, metadata, width) {

package/dist/pi-tui-runner.js

@@ -41,6 +41,7 @@ import { MakaAutocompleteAboveEditorComponent } from './tui-autocomplete-layout.
 import { TranscriptViewerOverlay } from './pi-tui-transcript-viewer.js';
 import { copyToClipboard } from './tui-clipboard.js';
 import { getTuiCopyCopy, lastAssistantText, serializeTranscriptText } from './tui-copy-command.js';
+import { getTuiHostOwnerCopy } from './tui-host-owner-copy.js';
 import { McpManagementOverlay } from './pi-tui-mcp-status.js';
 import { createShellRunElapsedTicker } from './shell-run-elapsed-ticker.js';
 import { createShellRunHydrationController } from './shell-run-hydration.js';
@@ -632,10 +633,8 @@ export async function runMakaPiTui(input) {
             rejectClosed(error);
         else
             resolveClosed();
-        // Runtime stop is best-effort after the shell has its terminal back. A
-        // double-Escape/Ctrl-C interrupt may already have one in flight; reuse it.
-        if (!interruptRequested)
-            void input.driver.stop().catch(() => { });
+        // Closing a viewport is not a Turn or Host stop. Explicit interrupt keys
+        // retain their own stop path; an attached Host continues independently.
     };
     const handleProcessExit = (exitCode, error) => {
         process.exitCode = exitCode;
@@ -2943,7 +2942,78 @@ export async function runMakaPiTui(input) {
             notice('Goal cleared.');
         }
     };
+    const runHostCommand = async (parts) => {
+        const copy = getTuiHostOwnerCopy(locale);
+        if (!input.hostControl)
+            throw new Error(copy.unavailable);
+        const action = parts[1] ?? 'status';
+        if (action === 'status' && parts.length <= 2) {
+            const text = await input.hostControl.status();
+            if (!closed) {
+                state.entries.push({ kind: 'notice', level: 'info', text });
+                requestRender();
+            }
+            return;
+        }
+        if (action !== 'stop' && action !== 'restart' && action !== 'update') {
+            throw new Error(copy.usage);
+        }
+        const targets = parts.slice(2);
+        if (targets.length > (action === 'update' ? 1 : 0)) {
+            throw new Error(copy.usage);
+        }
+        const accepted = await input.hostControl.prepare({
+            action,
+            ...(targets[0] ? { target: targets[0] } : {}),
+        }, (detail) => new Promise((resolve) => {
+            if (closed)
+                return resolve('cancel');
+            showSelectPicker(copy.pickerTitle, 'cancel', [
+                {
+                    value: 'cancel',
+                    label: copy.cancel,
+                    description: copy.cancelDescription,
+                },
+                {
+                    value: 'safe',
+                    label: copy.safe,
+                    description: copy.safeDescription,
+                },
+                ...(action === 'update'
+                    ? []
+                    : [
+                        {
+                            value: 'interrupt',
+                            label: copy.interrupt,
+                            description: copy.interruptDescription,
+                        },
+                    ]),
+            ], (item) => resolve(item.value), {
+                minPrimaryColumnWidth: 16,
+                maxPrimaryColumnWidth: 26,
+                selectedIndex: 0,
+                notice: detail,
+                onCancel: () => resolve('cancel'),
+            });
+        }));
+        if (accepted)
+            beginGracefulClose();
+    };
     const slashCommandHandlers = {
+        host: {
+            description: primaryGuidance.commands.host,
+            midTurn: 'local',
+            run: (parts) => {
+                void runHostCommand(parts).catch(reportError);
+            },
+        },
+        update: {
+            description: primaryGuidance.commands.update,
+            midTurn: 'local',
+            run: (parts) => {
+                void runHostCommand(['/host', 'update', ...parts.slice(1)]).catch(reportError);
+            },
+        },
         context: {
             description: primaryGuidance.commands.context,
             // Read-only diagnostics, but runControl-gated: mid-turn it would