salmon-loop 0.2.3 → 0.2.16

package/dist/core/protocols/a2a/agent-card.js

@@ -1,4 +1,5 @@
 export function buildA2AAgentCard(input) {
+    const capabilities = input.capabilities ?? [];
     const securitySchemes = input.security.length > 0
         ? Object.fromEntries(input.security.map((scheme, index) => [
             scheme.name ?? `${scheme.type}-${index}`,
@@ -18,10 +19,10 @@ export function buildA2AAgentCard(input) {
             streaming: input.capabilityOptions?.streaming ?? true,
             stateTransitionHistory: input.capabilityOptions?.stateTransitionHistory ?? true,
         },
-        skills: input.capabilities.map((capability) => ({
+        skills: capabilities.map((capability) => ({
             id: capability.id,
             name: capability.title,
-            description: capability.title,
+            description: capability.description ?? capability.title,
             tags: [],
         })),
         securitySchemes,

package/dist/core/protocols/a2a/sdk/executor.js

@@ -1,4 +1,6 @@
 import { InMemoryTaskStore } from '@a2a-js/sdk/server';
+import { buildCanonicalExecutionRequest, buildInstructionFromParts, } from '../../shared/execution-request.js';
+import { parseA2ASkillFlowMode } from '../../shared/flow-mode-mapping.js';
 export function createA2AInteractionExecutor(deps) {
     const store = deps.taskStore ?? new InMemoryTaskStore();
     const metadataByTaskId = new Map();
@@ -10,7 +12,7 @@ export function createA2AInteractionExecutor(deps) {
     const terminalPublished = new Set();
     return {
         async execute(requestContext, executionEventBus) {
-            const capability = deps.capabilityResolver?.(requestContext.userMessage) ?? 'patch';
+            const capability = parseA2ASkillFlowMode(deps.capabilityResolver?.(requestContext.userMessage)) ?? 'autopilot';
             const pendingEvents = [];
             let resolvedTaskId = null;
             let cleanedUp = false;
@@ -41,12 +43,13 @@ export function createA2AInteractionExecutor(deps) {
                 }
             };
             try {
-                const { task } = await deps.facade.createTask({
+                const executionRequest = buildCanonicalExecutionRequest({
                     capability,
-                    request: { instruction: extractInstruction(requestContext.userMessage) },
+                    instruction: extractInstruction(requestContext.userMessage),
                     // Pass SDK's taskId to facade to ensure consistency with eventBusManager
                     taskId: requestContext.taskId,
                 });
+                const { task } = await deps.facade.createTask(executionRequest);
                 resolvedTaskId = task.id;
                 cleanupByTaskId.set(task.id, cleanup);
                 metadataByTaskId.set(task.id, {
@@ -216,9 +219,8 @@ export function createA2AInteractionExecutor(deps) {
     function extractInstruction(message) {
         const textParts = message.parts
             .filter((part) => part.kind === 'text')
-            .map((part) => part.text.trim())
-            .filter(Boolean);
-        return textParts.join('\n') || 'Run task';
+            .map((part) => part.text);
+        return buildInstructionFromParts(textParts, { fallbackInstruction: 'Run task' });
     }
     function delay(ms) {
         return new Promise((resolve) => setTimeout(resolve, ms));

package/dist/core/protocols/a2a/sdk/server.js

@@ -7,7 +7,6 @@ export function createA2ASdkExpressApp(options) {
     const userBuilder = options.userBuilder ?? ((_) => UserBuilder.noAuthentication());
     const app = express();
     app.disable('x-powered-by');
-    app.use(express.json());
     const agentCardPath = options.agentCardPath ?? '/.well-known/agent-card.json';
     app.use(agentCardPath, agentCardHandler({
         agentCardProvider: () => requestHandler.getAgentCard(),

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

@@ -6,7 +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';
@@ -34,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;
@@ -52,6 +57,16 @@ function isAbsolutePath(filePath) {
         return true; // UNC path
     return false;
 }
+function deriveSessionTitleFromCwd(cwd) {
+    const trimmed = cwd.replace(/[\\/]+$/, '');
+    if (!trimmed)
+        return cwd;
+    const segments = trimmed.split(/[\\/]/).filter(Boolean);
+    const basename = segments.at(-1);
+    if (basename && basename.trim())
+        return basename;
+    return trimmed;
+}
 function ensureMarkdownParagraphBreak(text) {
     if (!text)
         return text;
@@ -71,14 +86,18 @@ function buildJsonResourceContentBlock(data) {
         },
     };
 }
-const defaultPromptCapabilities = {
-    image: false,
-    audio: false,
-    embeddedContext: false,
-};
 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}` : '';
@@ -224,11 +243,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 [
@@ -249,26 +267,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,
+            })),
         },
     ];
 }
@@ -294,12 +310,28 @@ function buildAvailableCommandsUpdateIfChanged(state) {
         availableCommands,
     };
 }
-function isSessionModeId(value) {
-    return value === 'interactive' || value === 'yolo';
+function buildSessionInfoUpdateIfChanged(session, state) {
+    const title = typeof session.title === 'string' ? session.title : null;
+    const updatedAt = typeof session.updatedAt === 'string' ? session.updatedAt : null;
+    const digest = JSON.stringify({ title, updatedAt });
+    if (digest === state.lastSessionInfoDigest)
+        return null;
+    state.lastSessionInfoDigest = digest;
+    return {
+        sessionUpdate: 'session_info_update',
+        title,
+        updatedAt,
+    };
 }
 function buildCurrentModeUpdate(modeId) {
     return { sessionUpdate: 'current_mode_update', currentModeId: modeId };
 }
+function buildModesState(modeId) {
+    return {
+        currentModeId: modeId,
+        availableModes: ACP_PUBLIC_MODES.map((mode) => ({ ...mode })),
+    };
+}
 function buildCurrentModeUpdateIfChanged(state) {
     const digest = state.modeId;
     if (digest === state.lastModeDigest)
@@ -307,18 +339,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,
@@ -326,6 +368,7 @@ function createSessionRuntimeStateFromPersisted(input) {
         lastCommandsDigest: null,
         lastConfigDigest: null,
         lastModeDigest: null,
+        lastSessionInfoDigest: null,
         permissionPolicy,
         modeId,
     };
@@ -456,6 +499,15 @@ export function createAcpFormalAgent(deps) {
         terminal: false,
     };
     const loadSessionCapability = deps.capabilityPolicy?.loadSession ?? true;
+    const promptCapabilities = {
+        image: deps.capabilityPolicy?.promptCapabilities?.image ?? false,
+        audio: deps.capabilityPolicy?.promptCapabilities?.audio ?? false,
+        embeddedContext: deps.capabilityPolicy?.promptCapabilities?.embeddedContext ?? false,
+    };
+    const mcpCapabilities = {
+        http: deps.capabilityPolicy?.mcpCapabilities?.http ?? false,
+        sse: deps.capabilityPolicy?.mcpCapabilities?.sse ?? false,
+    };
     const sessionPersistencePath = deps.sessionPersistencePath;
     const sessionStorePolicy = {
         maxEntries: deps.sessionStorePolicy?.maxEntries ?? ACP_SESSION_STORE_MAX_ENTRIES,
@@ -500,8 +552,10 @@ 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),
                 })),
             };
         }
@@ -711,6 +765,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,
                         }));
@@ -779,6 +834,21 @@ export function createAcpFormalAgent(deps) {
     async function emitSessionUpdate(sessionId, update) {
         await deps.conn.sessionUpdate({ sessionId, update });
     }
+    async function emitSessionInfoUpdateBestEffort(sessionId) {
+        const session = sessions.get(sessionId);
+        if (!session)
+            return;
+        const state = ensureSessionRuntimeState(sessionId);
+        const update = buildSessionInfoUpdateIfChanged(session, state);
+        if (!update)
+            return;
+        try {
+            await emitSessionUpdate(sessionId, update);
+        }
+        catch {
+            // Best-effort: do not fail the request due to notification delivery issues.
+        }
+    }
     async function emitRuntimePlanUpdateIfNeeded(params) {
         if (!shouldRefreshPlanForEvent(params.event))
             return;
@@ -833,10 +903,10 @@ export function createAcpFormalAgent(deps) {
         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;
     }
@@ -846,14 +916,22 @@ export function createAcpFormalAgent(deps) {
                 throw new RequestError(-32602, 'Invalid params: protocolVersion is required');
             }
             clientCapabilities = params.clientCapabilities;
+            // Protocol version negotiation:
+            // - If the client's requested version is supported, return the same version
+            // - Otherwise, return the latest version the agent supports
+            // Currently, the agent only supports protocol version 1
+            const supportedProtocolVersion = PROTOCOL_VERSION;
+            const negotiatedVersion = params.protocolVersion <= supportedProtocolVersion
+                ? params.protocolVersion
+                : supportedProtocolVersion;
             return {
-                protocolVersion: PROTOCOL_VERSION,
+                protocolVersion: negotiatedVersion,
                 agentInfo: deps.agentInfo,
                 authMethods: [],
                 agentCapabilities: {
                     loadSession: loadSessionCapability,
-                    promptCapabilities: defaultPromptCapabilities,
-                    mcpCapabilities: { http: false, sse: false },
+                    promptCapabilities: promptCapabilities,
+                    mcpCapabilities: mcpCapabilities,
                     sessionCapabilities: {},
                 },
             };
@@ -866,9 +944,14 @@ export function createAcpFormalAgent(deps) {
             if (!isAbsolutePath(params.cwd)) {
                 throw new RequestError(-32602, 'Invalid params: cwd must be an absolute path');
             }
-            const session = sessions.create({ cwd: params.cwd, mcpServers: params.mcpServers ?? [] });
+            const session = sessions.create({
+                cwd: params.cwd,
+                mcpServers: params.mcpServers ?? [],
+                title: deriveSessionTitleFromCwd(params.cwd),
+            });
             await persistSessionsBestEffort();
             const runtimeState = ensureSessionRuntimeState(session.id);
+            await emitSessionInfoUpdateBestEffort(session.id);
             // Restore session state on creation
             const commandsUpdate = buildAvailableCommandsUpdateIfChanged(runtimeState);
             if (commandsUpdate)
@@ -894,6 +977,7 @@ export function createAcpFormalAgent(deps) {
             return {
                 sessionId: session.id,
                 configOptions: buildConfigOptions(runtimeState),
+                modes: buildModesState(runtimeState.modeId),
                 ...(sessionMeta ? { _meta: sessionMeta } : {}),
             };
         },
@@ -902,8 +986,18 @@ export function createAcpFormalAgent(deps) {
                 throw new RequestError(-32601, '"Method not found": session/load');
             }
             await loadSessionInternal(params);
-            const session = sessions.get(params.sessionId);
+            let session = sessions.get(params.sessionId);
             const runtimeState = ensureSessionRuntimeState(session.id);
+            if (typeof session.title !== 'string' || !session.title.trim()) {
+                session =
+                    sessions.update(session.id, (current) => ({
+                        ...current,
+                        title: deriveSessionTitleFromCwd(current.cwd),
+                    })) ?? session;
+                await persistSessionsBestEffort();
+            }
+            runtimeState.lastSessionInfoDigest = null;
+            await emitSessionInfoUpdateBestEffort(session.id);
             // Restore plan state if session was running a task
             if (session.taskId && session.cwd) {
                 await emitRuntimePlanUpdateIfNeeded({
@@ -932,6 +1026,7 @@ export function createAcpFormalAgent(deps) {
             }
             const response = {
                 configOptions: buildConfigOptions(runtimeState),
+                modes: buildModesState(runtimeState.modeId),
             };
             if (deps.checkpointReader) {
                 const startedAt = Date.now();
@@ -1009,16 +1104,22 @@ 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}"`);
             }
             sessions.update(params.sessionId, (current) => ({ ...current }));
             await persistSessionsBestEffort();
+            await emitSessionInfoUpdateBestEffort(params.sessionId);
             const update = buildConfigOptionUpdateIfChanged(runtimeState);
             if (update) {
                 await emitSessionUpdate(params.sessionId, update);
@@ -1029,6 +1130,35 @@ export function createAcpFormalAgent(deps) {
             }
             return { configOptions: buildConfigOptions(runtimeState) };
         },
+        async setSessionMode(params) {
+            await hydrateSessionsOnce();
+            if (!sessions.get(params.sessionId)) {
+                throw new RequestError(-32004, `Session not found: ${params.sessionId}`);
+            }
+            const runtimeState = ensureSessionRuntimeState(params.sessionId);
+            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 = 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) {
+                await emitSessionUpdate(params.sessionId, modeUpdate);
+            }
+            return {};
+        },
         async prompt(params) {
             await hydrateSessionsOnce();
             const session = sessions.get(params.sessionId);
@@ -1039,12 +1169,20 @@ export function createAcpFormalAgent(deps) {
             const fsCaps = caps.fs;
             const clientExecutionReady = caps.terminal === true && Boolean(fsCaps?.readTextFile) && Boolean(fsCaps?.writeTextFile);
             const effectiveExecutionBinding = executionBinding === 'client' && !clientExecutionReady ? 'local' : executionBinding;
-            const promptText = extractTextFromPrompt(params.prompt, defaultPromptCapabilities);
+            const promptText = extractTextFromPrompt(params.prompt, promptCapabilities);
             const runtimeState = ensureSessionRuntimeState(params.sessionId);
+            // Check for cancellation before starting processing
+            if (sessions.get(params.sessionId)?.cancelRequested === true) {
+                return { stopReason: 'cancelled' };
+            }
             sessions.update(params.sessionId, (current) => {
+                const title = typeof current.title === 'string' && current.title.trim()
+                    ? current.title
+                    : deriveSessionTitleFromCwd(current.cwd);
                 return {
                     ...current,
                     cancelRequested: false,
+                    title,
                     history: [
                         ...current.history,
                         { role: 'user', content: params.prompt },
@@ -1052,6 +1190,7 @@ export function createAcpFormalAgent(deps) {
                 };
             });
             await persistSessionsBestEffort();
+            await emitSessionInfoUpdateBestEffort(params.sessionId);
             const configUpdate = buildConfigOptionUpdateIfChanged(runtimeState);
             if (configUpdate) {
                 await emitSessionUpdate(params.sessionId, configUpdate);
@@ -1083,16 +1222,23 @@ export function createAcpFormalAgent(deps) {
                         ],
                     }));
                     await persistSessionsBestEffort();
+                    await emitSessionInfoUpdateBestEffort(params.sessionId);
                     return { stopReason: 'end_turn' };
                 }
             }
+            // Check for cancellation again before creating task
+            if (sessions.get(params.sessionId)?.cancelRequested === true) {
+                return { stopReason: 'cancelled' };
+            }
+            const pendingUpdates = [];
+            const executionRequest = buildCanonicalExecutionRequest({
+                capability: runtimeState.modeId,
+                instruction: promptText,
+                checkpointSessionId: params.sessionId,
+                repoPath: session.cwd,
+            });
             const { task, signal } = await deps.facade.createTask({
-                capability: 'patch',
-                request: {
-                    instruction: promptText,
-                    checkpointSessionId: params.sessionId,
-                    repoPath: session.cwd,
-                },
+                ...executionRequest,
                 commandRunner: effectiveExecutionBinding === 'client'
                     ? createAcpCommandRunner({ conn: deps.conn, sessionId: params.sessionId })
                     : undefined,
@@ -1109,14 +1255,18 @@ export function createAcpFormalAgent(deps) {
                 authorizationMode: 'blocking',
                 onEvent: (event) => {
                     for (const update of loopEventToSessionUpdates(event, runtimeState)) {
-                        void emitSessionUpdate(params.sessionId, update);
+                        pendingUpdates.push(emitSessionUpdate(params.sessionId, update).catch(() => {
+                            // Ignore errors in session update notifications
+                        }));
                     }
-                    void emitRuntimePlanUpdateIfNeeded({
+                    pendingUpdates.push(emitRuntimePlanUpdateIfNeeded({
                         sessionId: params.sessionId,
                         repoPath: session.cwd,
                         event,
                         state: runtimeState,
-                    });
+                    }).catch(() => {
+                        // Ignore errors in plan update notifications
+                    }));
                 },
             });
             sessions.update(params.sessionId, (current) => ({ ...current, taskId: task.id }));
@@ -1181,6 +1331,17 @@ export function createAcpFormalAgent(deps) {
                 ],
             }));
             await persistSessionsBestEffort();
+            const latestSession = sessions.get(params.sessionId);
+            if (latestSession) {
+                const sessionInfoUpdate = buildSessionInfoUpdateIfChanged(latestSession, runtimeState);
+                if (sessionInfoUpdate) {
+                    pendingUpdates.push(emitSessionUpdate(params.sessionId, sessionInfoUpdate).catch(() => {
+                        // Ignore errors in session update notifications
+                    }));
+                }
+            }
+            // Wait for all pending session updates to be sent before responding
+            await Promise.all(pendingUpdates);
             return { stopReason };
         },
         async cancel(params) {
@@ -1188,11 +1349,16 @@ export function createAcpFormalAgent(deps) {
             const session = sessions.get(params.sessionId);
             if (!session)
                 return;
+            // Mark the session as cancelled
             sessions.update(params.sessionId, (current) => ({ ...current, cancelRequested: true }));
             await persistSessionsBestEffort();
+            await emitSessionInfoUpdateBestEffort(params.sessionId);
+            // If a task is running, cancel it
             if (session.taskId) {
                 await deps.facade.cancelTask(session.taskId);
             }
+            // Note: The prompt method will check the cancelRequested flag and return
+            // StopReason::Cancelled as required by the protocol
         },
         extMethod: async () => ({}),
         extNotification: async () => { },

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

@@ -60,6 +60,23 @@ function toToolCallUpdate(request) {
     };
 }
 export function createAcpToolAuthorizationProvider(params) {
+    const inProgressEmitted = new Set();
+    const emitInProgressBestEffort = async (toolCallId) => {
+        if (inProgressEmitted.has(toolCallId))
+            return;
+        inProgressEmitted.add(toolCallId);
+        try {
+            const update = {
+                sessionUpdate: 'tool_call_update',
+                toolCallId,
+                status: 'in_progress',
+            };
+            await params.conn.sessionUpdate({ sessionId: params.sessionId, update });
+        }
+        catch {
+            // Best-effort: do not block authorization if the client can't accept updates.
+        }
+    };
     return {
         async requestAuthorization(request) {
             const enforceClientCapabilities = params.enforceClientCapabilities ?? true;
@@ -86,7 +103,8 @@ export function createAcpToolAuthorizationProvider(params) {
             }
             const permissionPolicy = params.getPermissionPolicy?.() ?? 'ask';
             if (permissionPolicy === 'allow_all') {
-                return { outcome: 'allow_session', source: 'auto', reason: 'session_mode:yolo' };
+                await emitInProgressBestEffort(request.id);
+                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) {
@@ -103,8 +121,10 @@ export function createAcpToolAuthorizationProvider(params) {
             }
             switch (response.outcome.optionId) {
                 case 'allow_once':
+                    await emitInProgressBestEffort(request.id);
                     return { outcome: 'allow_once', source: 'user' };
                 case 'allow_always':
+                    await emitInProgressBestEffort(request.id);
                     return { outcome: 'allow_session', source: 'user' };
                 case 'reject_once':
                 case 'reject_always':

package/dist/core/protocols/shared/execution-request.js

@@ -0,0 +1,24 @@
+export function normalizeInstructionText(instruction, options) {
+    const normalized = instruction.replace(/\r\n?/g, '\n').trim();
+    if (normalized.length > 0)
+        return normalized;
+    return options?.fallbackInstruction ?? '';
+}
+export function buildInstructionFromParts(parts, options) {
+    return normalizeInstructionText(parts.join('\n'), options);
+}
+export function buildCanonicalExecutionRequest(input) {
+    const request = {
+        instruction: normalizeInstructionText(input.instruction, {
+            fallbackInstruction: input.fallbackInstruction,
+        }),
+        checkpointSessionId: input.checkpointSessionId,
+        repoPath: input.repoPath,
+    };
+    return {
+        capability: input.capability,
+        request,
+        taskId: input.taskId,
+    };
+}
+//# sourceMappingURL=execution-request.js.map