salmon-loop 0.2.13 → 0.3.0

package/dist/core/protocols/acp/formal-agent.js

@@ -6,8 +6,11 @@ import { defaultPathAdapter } from '../../adapters/path/path-adapter.js';
 import { inferTurnStopReasonFromFailure } from '../../interaction/turn-stop-reason.js';
 import { recordAuditEvent } from '../../observability/audit-trail.js';
 import { readPlan } from '../../plan/index.js';
+import { toAcpPublicModes } from '../../public-capabilities/projections.js';
+import { buildPublicCapabilityRegistry } from '../../public-capabilities/registry.js';
 import { parseSlashInput } from '../../slash/parser.js';
 import { buildCanonicalExecutionRequest } from '../shared/execution-request.js';
+import { parseAcpFlowMode } from '../shared/flow-mode-mapping.js';
 import { createAcpCommandRunner } from './acp-command-runner.js';
 import { createAcpFileSystem } from './acp-filesystem.js';
 import { createAcpSessionStore, isTerminalTaskEvent } from './handlers.js';
@@ -35,7 +38,8 @@ const ACP_PERMISSION_POLICY_CONFIG_ID = '_salmonloop_permission_policy';
 const ACP_MODE_CONFIG_ID = '_salmonloop_mode';
 const ACP_PERMISSION_POLICY_ASK = 'ask';
 const ACP_PERMISSION_POLICY_DENY_ALL = 'deny_all';
-const ACP_DEFAULT_MODE_ID = 'interactive';
+const ACP_PERMISSION_POLICY_ALLOW_ALL = 'allow_all';
+const ACP_DEFAULT_MODE_ID = 'autopilot';
 const ACP_SESSION_STORE_MAX_ENTRIES = 200;
 const ACP_SESSION_STORE_MAX_AGE_MS = 1000 * 60 * 60 * 24 * 30;
 const ACP_SESSION_STORE_LOCK_STALE_MS = 1000 * 30;
@@ -85,11 +89,35 @@ function buildJsonResourceContentBlock(data) {
 const ACP_AVAILABLE_COMMANDS = [
     { name: 'help', description: text.acp.slashHelpDescription },
 ];
+const ACP_PUBLIC_MODES = toAcpPublicModes(buildPublicCapabilityRegistry());
+const ACP_PUBLIC_MODE_IDS = new Set(ACP_PUBLIC_MODES.map((mode) => mode.id));
+function resolveExposedAcpModeId(value, fallback = ACP_DEFAULT_MODE_ID) {
+    const resolvedModeId = parseAcpFlowMode(value);
+    if (resolvedModeId && ACP_PUBLIC_MODE_IDS.has(resolvedModeId)) {
+        return resolvedModeId;
+    }
+    return fallback;
+}
 function formatResourceLink(block) {
     const title = block.title ?? block.name ?? block.uri;
     const description = block.description ? ` - ${block.description}` : '';
     return `Resource: ${title} (${block.uri})${description}`;
 }
+function formatEmbeddedResource(block) {
+    const resource = block.resource;
+    const uri = typeof resource.uri === 'string' ? resource.uri : 'embedded-resource';
+    const mimeType = typeof resource.mimeType === 'string' ? resource.mimeType : undefined;
+    if (typeof resource.text === 'string') {
+        const header = mimeType
+            ? `Embedded resource: ${uri} (${mimeType})`
+            : `Embedded resource: ${uri}`;
+        return `${header}\n${resource.text}`;
+    }
+    const header = mimeType
+        ? `Embedded binary resource: ${uri} (${mimeType})`
+        : `Embedded binary resource: ${uri}`;
+    return header;
+}
 function extractTextFromPrompt(prompt, capabilities) {
     const parts = [];
     for (const block of prompt) {
@@ -114,6 +142,7 @@ function extractTextFromPrompt(prompt, capabilities) {
                 if (!capabilities.embeddedContext) {
                     throw new RequestError(-32000, 'Prompt content type resource is not supported');
                 }
+                parts.push(formatEmbeddedResource(block));
                 break;
             default:
                 throw new RequestError(-32602, 'Invalid params: unsupported content block type');
@@ -230,11 +259,10 @@ function loopEventToSessionUpdate(event) {
             return null;
     }
 }
-function createSessionRuntimeState() {
-    return createSessionRuntimeStateFromPersisted();
-}
 function isPermissionPolicyValue(value) {
-    return value === ACP_PERMISSION_POLICY_ASK || value === ACP_PERMISSION_POLICY_DENY_ALL;
+    return (value === ACP_PERMISSION_POLICY_ASK ||
+        value === ACP_PERMISSION_POLICY_DENY_ALL ||
+        value === ACP_PERMISSION_POLICY_ALLOW_ALL);
 }
 function buildConfigOptions(state) {
     return [
@@ -255,26 +283,24 @@ function buildConfigOptions(state) {
                     name: text.acp.permissionPolicyDenyAllName,
                     description: text.acp.permissionPolicyDenyAllDescription,
                 },
+                {
+                    value: ACP_PERMISSION_POLICY_ALLOW_ALL,
+                    name: text.acp.permissionPolicyAllowAllName,
+                    description: text.acp.permissionPolicyAllowAllDescription,
+                },
             ],
         },
         {
             type: 'select',
             id: ACP_MODE_CONFIG_ID,
-            name: 'Session Mode',
-            description: text.acp.modeInteractiveDescription,
+            name: 'Execution Flow',
+            description: 'Choose how the agent should execute this session.',
             currentValue: state.modeId,
-            options: [
-                {
-                    value: 'interactive',
-                    name: 'Interactive',
-                    description: text.acp.modeInteractiveDescription,
-                },
-                {
-                    value: 'yolo',
-                    name: 'YOLO',
-                    description: text.acp.modeYoloDescription,
-                },
-            ],
+            options: ACP_PUBLIC_MODES.map((mode) => ({
+                value: mode.id,
+                name: mode.name,
+                description: mode.description,
+            })),
         },
     ];
 }
@@ -313,27 +339,13 @@ function buildSessionInfoUpdateIfChanged(session, state) {
         updatedAt,
     };
 }
-function isSessionModeId(value) {
-    return value === 'interactive' || value === 'yolo';
-}
 function buildCurrentModeUpdate(modeId) {
     return { sessionUpdate: 'current_mode_update', currentModeId: modeId };
 }
 function buildModesState(modeId) {
     return {
         currentModeId: modeId,
-        availableModes: [
-            {
-                id: 'interactive',
-                name: 'Interactive',
-                description: text.acp.modeInteractiveDescription,
-            },
-            {
-                id: 'yolo',
-                name: 'YOLO',
-                description: text.acp.modeYoloDescription,
-            },
-        ],
+        availableModes: ACP_PUBLIC_MODES.map((mode) => ({ ...mode })),
     };
 }
 function buildCurrentModeUpdateIfChanged(state) {
@@ -343,18 +355,28 @@ function buildCurrentModeUpdateIfChanged(state) {
     state.lastModeDigest = digest;
     return buildCurrentModeUpdate(state.modeId);
 }
+function getLegacyPermissionPolicyForModeValue(value) {
+    const normalized = String(value ?? '')
+        .trim()
+        .toLowerCase();
+    if (normalized === 'interactive')
+        return ACP_PERMISSION_POLICY_ASK;
+    if (normalized === 'yolo')
+        return ACP_PERMISSION_POLICY_ALLOW_ALL;
+    return null;
+}
 function getPermissionPolicyForAuthorization(state) {
-    if (state.modeId === 'yolo')
-        return 'allow_all';
     return state.permissionPolicy;
 }
 function createSessionRuntimeStateFromPersisted(input) {
+    const defaultPermissionPolicy = isPermissionPolicyValue(String(input?.defaultPermissionPolicy))
+        ? input?.defaultPermissionPolicy
+        : ACP_PERMISSION_POLICY_ASK;
     const permissionPolicy = isPermissionPolicyValue(String(input?.permissionPolicy))
         ? input?.permissionPolicy
-        : ACP_PERMISSION_POLICY_ASK;
-    const modeId = isSessionModeId(String(input?.modeId))
-        ? input?.modeId
-        : (input?.defaultModeId ?? ACP_DEFAULT_MODE_ID);
+        : defaultPermissionPolicy;
+    const defaultModeId = resolveExposedAcpModeId(input?.defaultModeId);
+    const modeId = resolveExposedAcpModeId(input?.modeId, defaultModeId);
     const state = {
         runtimePlanSessionId: null,
         runtimePlanPathHint: null,
@@ -444,6 +466,74 @@ function buildPlanUpdateFromCoreIfChanged(read, state) {
         entries,
     };
 }
+function envListToRecord(env) {
+    const record = {};
+    for (const entry of env) {
+        record[entry.name] = entry.value;
+    }
+    return record;
+}
+function headersListToRecord(headers) {
+    const record = {};
+    for (const entry of headers) {
+        record[entry.name] = entry.value;
+    }
+    return record;
+}
+function acpMcpServersToResolved(mcpServers) {
+    if (!Array.isArray(mcpServers))
+        return [];
+    const resolved = [];
+    for (const server of mcpServers) {
+        const transportType = 'type' in server ? server.type : 'stdio';
+        if (transportType === 'sse' || transportType === 'acp') {
+            throw new RequestError(-32602, `Invalid params: unsupported MCP server transport "${transportType}"`);
+        }
+        if ('type' in server && server.type === 'http') {
+            const httpServer = server;
+            resolved.push({
+                name: httpServer.name,
+                enabled: true,
+                transport: 'http',
+                url: httpServer.url,
+                headers: headersListToRecord(httpServer.headers),
+                allowTools: ['*'],
+                allowResources: [],
+                scope: 'repo',
+            });
+            continue;
+        }
+        if (transportType !== 'stdio') {
+            throw new RequestError(-32602, `Invalid params: unsupported MCP server transport "${transportType}"`);
+        }
+        const stdioServer = server;
+        resolved.push({
+            name: stdioServer.name,
+            enabled: true,
+            transport: 'stdio',
+            command: stdioServer.command,
+            args: stdioServer.args,
+            env: envListToRecord(stdioServer.env),
+            allowTools: ['*'],
+            allowResources: [],
+            scope: 'repo',
+        });
+    }
+    return resolved;
+}
+function acpMcpServersToExtensions(mcpServers) {
+    const resolvedServers = acpMcpServersToResolved(mcpServers);
+    if (resolvedServers.length === 0)
+        return undefined;
+    return {
+        mcpServers: resolvedServers,
+        toolPlugins: [],
+        skillDiscovery: { paths: [], scope: 'repo' },
+    };
+}
+function validateAcpMcpServers(mcpServers) {
+    void acpMcpServersToResolved(mcpServers);
+}
 function extractSlashInput(prompt) {
     if (prompt.length !== 1)
         return null;
@@ -499,8 +589,9 @@ export function createAcpFormalAgent(deps) {
         embeddedContext: deps.capabilityPolicy?.promptCapabilities?.embeddedContext ?? false,
     };
     const mcpCapabilities = {
-        http: deps.capabilityPolicy?.mcpCapabilities?.http ?? false,
+        http: deps.capabilityPolicy?.mcpCapabilities?.http ?? true,
         sse: deps.capabilityPolicy?.mcpCapabilities?.sse ?? false,
+        acp: deps.capabilityPolicy?.mcpCapabilities?.acp ?? false,
     };
     const sessionPersistencePath = deps.sessionPersistencePath;
     const sessionStorePolicy = {
@@ -514,6 +605,7 @@ export function createAcpFormalAgent(deps) {
     const executionBinding = deps.executionBinding ?? 'local';
     let sessionsHydrated = false;
     let hydratePromise = null;
+    const deletedSessionIds = new Map();
     function parseTimestamp(value) {
         if (typeof value !== 'string' || value.length === 0)
             return 0;
@@ -527,6 +619,31 @@ export function createAcpFormalAgent(deps) {
             .sort((a, b) => parseTimestamp(b.updatedAt) - parseTimestamp(a.updatedAt))
             .slice(0, sessionStorePolicy.maxEntries);
     }
+    function normalizeDeletedSessionRecords(input) {
+        if (!Array.isArray(input))
+            return [];
+        const byId = new Map();
+        for (const entry of input) {
+            if (!entry || typeof entry !== 'object')
+                continue;
+            const record = entry;
+            if (typeof record.id !== 'string' || !record.id)
+                continue;
+            if (typeof record.deletedAt !== 'string' || !record.deletedAt)
+                continue;
+            const current = byId.get(record.id);
+            if (!current || parseTimestamp(record.deletedAt) > parseTimestamp(current.deletedAt)) {
+                byId.set(record.id, { id: record.id, deletedAt: record.deletedAt });
+            }
+        }
+        return Array.from(byId.values());
+    }
+    function pruneDeletedSessionRecords(records) {
+        const cutoff = Date.now() - sessionStorePolicy.maxAgeMs;
+        return normalizeDeletedSessionRecords(records)
+            .filter((record) => parseTimestamp(record.deletedAt) >= cutoff)
+            .sort((a, b) => parseTimestamp(b.deletedAt) - parseTimestamp(a.deletedAt));
+    }
     function normalizePersistedSessionStore(input) {
         if (!input || typeof input !== 'object') {
             return { schemaVersion: 2, sessions: [] };
@@ -546,13 +663,20 @@ export function createAcpFormalAgent(deps) {
                     title: entry.title,
                     taskId: undefined,
                     history: [],
-                    permissionPolicy: ACP_PERMISSION_POLICY_ASK,
-                    modeId: deps.defaultModeId ?? ACP_DEFAULT_MODE_ID,
+                    permissionPolicy: isPermissionPolicyValue(String(deps.defaultPermissionPolicy))
+                        ? deps.defaultPermissionPolicy
+                        : ACP_PERMISSION_POLICY_ASK,
+                    modeId: resolveExposedAcpModeId(deps.defaultModeId),
                 })),
+                deletedSessions: [],
             };
         }
         if (raw.schemaVersion === 2) {
-            return { schemaVersion: 2, sessions: raw.sessions };
+            return {
+                schemaVersion: 2,
+                sessions: raw.sessions,
+                deletedSessions: pruneDeletedSessionRecords(raw.deletedSessions),
+            };
         }
         return { schemaVersion: 2, sessions: [] };
     }
@@ -608,6 +732,7 @@ export function createAcpFormalAgent(deps) {
             }
         }
         const payload = { schemaVersion: 2, sessions: prunedRecords };
+        const payloadDeletedSessions = pruneDeletedSessionRecords(Array.from(deletedSessionIds, ([id, deletedAt]) => ({ id, deletedAt })));
         const primaryRepoPath = prunedRecords[0]?.cwd;
         const lockAuditDetails = {
             lockPath,
@@ -691,13 +816,24 @@ export function createAcpFormalAgent(deps) {
                     // ignore read failure; writing fresh payload is acceptable
                 }
                 const merged = new Map();
+                const mergedDeletedSessions = pruneDeletedSessionRecords([
+                    ...(existing.deletedSessions ?? []),
+                    ...payloadDeletedSessions,
+                ]);
+                const mergedDeletedIds = new Set(mergedDeletedSessions.map((record) => record.id));
+                for (const record of mergedDeletedSessions) {
+                    deletedSessionIds.set(record.id, record.deletedAt);
+                }
                 for (const entry of existing.sessions)
                     merged.set(entry.id, entry);
                 for (const entry of payload.sessions)
                     merged.set(entry.id, entry);
+                for (const id of mergedDeletedIds)
+                    merged.delete(id);
                 const mergedPayload = {
                     schemaVersion: 2,
                     sessions: pruneSessionRecords(Array.from(merged.values())),
+                    deletedSessions: mergedDeletedSessions,
                 };
                 await writeFile(tempPath, JSON.stringify(mergedPayload, null, 2), 'utf8');
                 await rename(tempPath, sessionPersistencePath);
@@ -740,7 +876,13 @@ export function createAcpFormalAgent(deps) {
             try {
                 const raw = await readFile(sessionPersistencePath, 'utf8');
                 const parsed = normalizePersistedSessionStore(JSON.parse(raw));
+                const deletedIds = new Set(parsed.deletedSessions?.map((record) => record.id) ?? []);
+                for (const record of parsed.deletedSessions ?? []) {
+                    deletedSessionIds.set(record.id, record.deletedAt);
+                }
                 for (const stored of pruneSessionRecords(parsed.sessions)) {
+                    if (deletedIds.has(stored.id))
+                        continue;
                     sessions.upsert({
                         id: stored.id,
                         cwd: stored.cwd,
@@ -757,6 +899,7 @@ export function createAcpFormalAgent(deps) {
                     if (!sessionRuntime.has(stored.id)) {
                         sessionRuntime.set(stored.id, createSessionRuntimeStateFromPersisted({
                             permissionPolicy: stored.permissionPolicy,
+                            defaultPermissionPolicy: deps.defaultPermissionPolicy,
                             modeId: stored.modeId,
                             defaultModeId: deps.defaultModeId,
                         }));
@@ -876,28 +1019,58 @@ export function createAcpFormalAgent(deps) {
     }
     async function loadSessionInternal(params) {
         await hydrateSessionsOnce();
+        validateAcpMcpServers(params.mcpServers);
         const session = sessions.get(params.sessionId);
         if (!session) {
             throw new RequestError(-32004, `Session not found: ${params.sessionId}`);
         }
         if (session.cwd !== params.cwd) {
+            throw new RequestError(-32602, 'Invalid params: cwd does not match session cwd');
+        }
+        if (params.mcpServers) {
+            sessions.update(params.sessionId, (current) => ({
+                ...current,
+                mcpServers: params.mcpServers,
+            }));
+            await persistSessionsBestEffort();
+        }
+        return session;
+    }
+    async function resumeSessionInternal(params) {
+        await hydrateSessionsOnce();
+        validateAcpMcpServers(params.mcpServers);
+        const session = sessions.get(params.sessionId);
+        if (!session) {
+            throw new RequestError(-32004, `Session not found: ${params.sessionId}`);
+        }
+        if (session.cwd !== params.cwd) {
+            throw new RequestError(-32602, 'Invalid params: cwd does not match session cwd');
+        }
+        if (params.mcpServers) {
             sessions.update(params.sessionId, (current) => ({
                 ...current,
-                cwd: params.cwd,
                 mcpServers: params.mcpServers ?? [],
             }));
             await persistSessionsBestEffort();
         }
         return session;
     }
+    function toSessionInfo(session) {
+        return {
+            sessionId: session.id,
+            cwd: session.cwd,
+            title: typeof session.title === 'string' && session.title.trim() ? session.title : null,
+            updatedAt: session.updatedAt,
+        };
+    }
     function ensureSessionRuntimeState(sessionId) {
         const existing = sessionRuntime.get(sessionId);
         if (existing)
             return existing;
-        const created = createSessionRuntimeState();
-        if (deps.defaultModeId) {
-            created.modeId = deps.defaultModeId;
-        }
+        const created = createSessionRuntimeStateFromPersisted({
+            defaultPermissionPolicy: deps.defaultPermissionPolicy,
+            defaultModeId: deps.defaultModeId,
+        });
         sessionRuntime.set(sessionId, created);
         return created;
     }
@@ -923,7 +1096,11 @@ export function createAcpFormalAgent(deps) {
                     loadSession: loadSessionCapability,
                     promptCapabilities: promptCapabilities,
                     mcpCapabilities: mcpCapabilities,
-                    sessionCapabilities: {},
+                    sessionCapabilities: {
+                        list: {},
+                        resume: {},
+                        close: {},
+                    },
                 },
             };
         },
@@ -935,6 +1112,7 @@ export function createAcpFormalAgent(deps) {
             if (!isAbsolutePath(params.cwd)) {
                 throw new RequestError(-32602, 'Invalid params: cwd must be an absolute path');
             }
+            validateAcpMcpServers(params.mcpServers);
             const session = sessions.create({
                 cwd: params.cwd,
                 mcpServers: params.mcpServers ?? [],
@@ -1004,12 +1182,10 @@ export function createAcpFormalAgent(deps) {
             if (modeUpdate)
                 await emitSessionUpdate(session.id, modeUpdate);
             for (const entry of session.history) {
-                if (entry.role !== 'assistant')
-                    continue;
                 for (const block of entry.content) {
                     if (block.type === 'text' && typeof block.text === 'string' && block.text.trim()) {
                         await emitSessionUpdate(session.id, {
-                            sessionUpdate: 'agent_message_chunk',
+                            sessionUpdate: entry.role === 'assistant' ? 'agent_message_chunk' : 'user_message_chunk',
                             content: buildTextContentBlock(block.text),
                         });
                     }
@@ -1082,12 +1258,63 @@ export function createAcpFormalAgent(deps) {
             }
             return response;
         },
+        async listSessions(params) {
+            await hydrateSessionsOnce();
+            if (typeof params.cwd === 'string' && params.cwd && !isAbsolutePath(params.cwd)) {
+                throw new RequestError(-32602, 'Invalid params: cwd must be an absolute path');
+            }
+            const filtered = sessions
+                .list()
+                .filter((session) => !params.cwd || session.cwd === params.cwd)
+                .sort((a, b) => parseTimestamp(b.updatedAt) - parseTimestamp(a.updatedAt));
+            return {
+                sessions: filtered.map(toSessionInfo),
+            };
+        },
+        async resumeSession(params) {
+            const session = await resumeSessionInternal({
+                sessionId: params.sessionId,
+                cwd: params.cwd,
+                mcpServers: params.mcpServers,
+            });
+            const runtimeState = ensureSessionRuntimeState(session.id);
+            runtimeState.lastSessionInfoDigest = null;
+            await emitSessionInfoUpdateBestEffort(session.id);
+            const commandsUpdate = buildAvailableCommandsUpdateIfChanged(runtimeState);
+            if (commandsUpdate)
+                await emitSessionUpdate(session.id, commandsUpdate);
+            const modeUpdate = buildCurrentModeUpdateIfChanged(runtimeState);
+            if (modeUpdate)
+                await emitSessionUpdate(session.id, modeUpdate);
+            return {
+                configOptions: buildConfigOptions(runtimeState),
+                modes: buildModesState(runtimeState.modeId),
+            };
+        },
+        async closeSession(params) {
+            await hydrateSessionsOnce();
+            const session = sessions.get(params.sessionId);
+            if (!session)
+                return {};
+            sessions.update(params.sessionId, (current) => ({ ...current, cancelRequested: true }));
+            if (session.taskId) {
+                await deps.facade.cancelTask(session.taskId);
+            }
+            deletedSessionIds.set(params.sessionId, new Date().toISOString());
+            sessionRuntime.delete(params.sessionId);
+            sessions.delete(params.sessionId);
+            await persistSessionsBestEffort();
+            return {};
+        },
         async setSessionConfigOption(params) {
             await hydrateSessionsOnce();
             if (!sessions.get(params.sessionId)) {
                 throw new RequestError(-32004, `Session not found: ${params.sessionId}`);
             }
             const runtimeState = ensureSessionRuntimeState(params.sessionId);
+            if (typeof params.value !== 'string') {
+                throw new RequestError(-32602, `Invalid params: unsupported non-string value for "${params.configId}"`);
+            }
             if (params.configId === ACP_PERMISSION_POLICY_CONFIG_ID) {
                 if (!isPermissionPolicyValue(params.value)) {
                     throw new RequestError(-32602, `Invalid params: unsupported value "${params.value}" for "${params.configId}"`);
@@ -1095,10 +1322,15 @@ export function createAcpFormalAgent(deps) {
                 runtimeState.permissionPolicy = params.value;
             }
             else if (params.configId === ACP_MODE_CONFIG_ID) {
-                if (!isSessionModeId(params.value)) {
+                const parsedModeId = parseAcpFlowMode(params.value);
+                if (!parsedModeId || !ACP_PUBLIC_MODE_IDS.has(parsedModeId)) {
                     throw new RequestError(-32602, `Invalid params: unsupported value "${params.value}" for "${params.configId}"`);
                 }
-                runtimeState.modeId = params.value;
+                runtimeState.modeId = parsedModeId;
+                const legacyPermissionPolicy = getLegacyPermissionPolicyForModeValue(params.value);
+                if (legacyPermissionPolicy) {
+                    runtimeState.permissionPolicy = legacyPermissionPolicy;
+                }
             }
             else {
                 throw new RequestError(-32602, `Invalid params: unsupported configId "${params.configId}"`);
@@ -1122,13 +1354,22 @@ export function createAcpFormalAgent(deps) {
                 throw new RequestError(-32004, `Session not found: ${params.sessionId}`);
             }
             const runtimeState = ensureSessionRuntimeState(params.sessionId);
-            if (!isSessionModeId(params.modeId)) {
+            const resolvedModeId = parseAcpFlowMode(params.modeId);
+            if (!resolvedModeId || !ACP_PUBLIC_MODE_IDS.has(resolvedModeId)) {
                 throw new RequestError(-32602, `Invalid params: unsupported modeId "${params.modeId}"`);
             }
-            runtimeState.modeId = params.modeId;
+            runtimeState.modeId = resolvedModeId;
+            const legacyPermissionPolicy = getLegacyPermissionPolicyForModeValue(params.modeId);
+            if (legacyPermissionPolicy) {
+                runtimeState.permissionPolicy = legacyPermissionPolicy;
+            }
             sessions.update(params.sessionId, (current) => ({ ...current }));
             await persistSessionsBestEffort();
             await emitSessionInfoUpdateBestEffort(params.sessionId);
+            const configUpdate = buildConfigOptionUpdateIfChanged(runtimeState);
+            if (configUpdate) {
+                await emitSessionUpdate(params.sessionId, configUpdate);
+            }
             // Send mode update notification
             const modeUpdate = buildCurrentModeUpdateIfChanged(runtimeState);
             if (modeUpdate) {
@@ -1209,7 +1450,7 @@ export function createAcpFormalAgent(deps) {
             }
             const pendingUpdates = [];
             const executionRequest = buildCanonicalExecutionRequest({
-                capability: 'patch',
+                capability: runtimeState.modeId,
                 instruction: promptText,
                 checkpointSessionId: params.sessionId,
                 repoPath: session.cwd,
@@ -1222,6 +1463,7 @@ export function createAcpFormalAgent(deps) {
                 fileSystemOverride: effectiveExecutionBinding === 'client'
                     ? createAcpFileSystem({ conn: deps.conn, sessionId: params.sessionId })
                     : undefined,
+                extensions: acpMcpServersToExtensions(session.mcpServers),
                 authorizationProvider: createAcpToolAuthorizationProvider({
                     conn: deps.conn,
                     sessionId: params.sessionId,

package/dist/core/protocols/acp/handlers.js

@@ -30,7 +30,11 @@ export function createAcpSessionStore() {
             if (!current)
                 return undefined;
             const updated = mutate(current);
-            updated.updatedAt = new Date().toISOString();
+            const nextUpdatedAt = new Date().toISOString();
+            updated.updatedAt =
+                nextUpdatedAt > current.updatedAt
+                    ? nextUpdatedAt
+                    : new Date(Date.parse(current.updatedAt) + 1).toISOString();
             sessions.set(id, updated);
             return updated;
         },

package/dist/core/protocols/acp/permission-provider.js

@@ -104,7 +104,7 @@ export function createAcpToolAuthorizationProvider(params) {
             const permissionPolicy = params.getPermissionPolicy?.() ?? 'ask';
             if (permissionPolicy === 'allow_all') {
                 await emitInProgressBestEffort(request.id);
-                return { outcome: 'allow_session', source: 'auto', reason: 'session_mode:yolo' };
+                return { outcome: 'allow_session', source: 'auto', reason: 'session_config:allow_all' };
             }
             const hasSideEffects = request.sideEffects.some((effect) => effect !== 'fs_read');
             if (permissionPolicy === 'deny_all' && hasSideEffects) {

package/dist/core/protocols/shared/flow-mode-mapping.js

@@ -0,0 +1,23 @@
+import { FLOW_MODE_PUBLIC_METADATA } from '../../public-capabilities/flow-mode-metadata.js';
+import { FLOW_MODES, parseFlowMode } from '../../types/flow-mode.js';
+export const SUPPORTED_PROTOCOL_FLOW_MODES = FLOW_MODES;
+export function parseAcpFlowMode(value) {
+    const normalized = String(value ?? '')
+        .trim()
+        .toLowerCase();
+    if (normalized === 'interactive' || normalized === 'yolo') {
+        return 'autopilot';
+    }
+    return parseFlowMode(normalized);
+}
+export function parseA2ASkillFlowMode(value) {
+    return parseFlowMode(value);
+}
+export function buildA2AFlowSkills() {
+    return SUPPORTED_PROTOCOL_FLOW_MODES.map((mode) => ({
+        id: mode,
+        title: FLOW_MODE_PUBLIC_METADATA[mode].a2aTitle,
+        description: FLOW_MODE_PUBLIC_METADATA[mode].description,
+    }));
+}
+//# sourceMappingURL=flow-mode-mapping.js.map