salmon-loop 0.2.3 → 0.2.13

package/dist/core/config/load.js

@@ -1,14 +1,9 @@
 import { readFile } from '../adapters/fs/node-fs.js';
 import { ConfigError } from './errors.js';
 import { parseConfigText } from './file-format.js';
-import { getDefaultRepoConfigPaths, resolveConfigPath } from './paths.js';
+import { getDefaultRepoConfigPaths, getDefaultUserConfigPaths, resolveConfigPath, } from './paths.js';
 import { validateConfigFileV1 } from './validate.js';
-export async function tryLoadConfigFile(opts) {
-    if (!opts.enabled)
-        return null;
-    const candidatePaths = opts.configPath
-        ? [resolveConfigPath(opts.repoRoot, opts.configPath)]
-        : getDefaultRepoConfigPaths(opts.repoRoot);
+async function loadFromCandidates(candidatePaths, required) {
     for (let i = 0; i < candidatePaths.length; i++) {
         const absPath = candidatePaths[i];
         try {
@@ -21,7 +16,7 @@ export async function tryLoadConfigFile(opts) {
             if ((e && typeof e === 'object' && 'code' in e ? e.code : undefined) ===
                 'ENOENT') {
                 const isLast = i === candidatePaths.length - 1;
-                if (opts.required && isLast) {
+                if (required && isLast) {
                     throw new ConfigError('CONFIG_FILE_NOT_FOUND', { path: absPath });
                 }
                 continue;
@@ -31,4 +26,23 @@ export async function tryLoadConfigFile(opts) {
     }
     return null;
 }
+export async function tryLoadConfigFile(opts) {
+    if (!opts.enabled)
+        return null;
+    const candidatePaths = opts.configPath
+        ? [resolveConfigPath(opts.repoRoot, opts.configPath)]
+        : getDefaultRepoConfigPaths(opts.repoRoot);
+    return loadFromCandidates(candidatePaths, opts.required);
+}
+export async function loadConfigStack(opts) {
+    if (!opts.enabled)
+        return {};
+    if (opts.configPath) {
+        const loaded = await tryLoadConfigFile(opts);
+        return loaded ? { repo: loaded } : {};
+    }
+    const repo = await loadFromCandidates(getDefaultRepoConfigPaths(opts.repoRoot), false);
+    const user = await loadFromCandidates(getDefaultUserConfigPaths(), false);
+    return { repo: repo ?? undefined, user: user ?? undefined };
+}
 //# sourceMappingURL=load.js.map

package/dist/core/config/merge.js

@@ -0,0 +1,27 @@
+function isPlainObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function mergeValues(userValue, repoValue) {
+    if (repoValue === undefined)
+        return userValue;
+    if (userValue === undefined)
+        return repoValue;
+    if (isPlainObject(userValue) && isPlainObject(repoValue)) {
+        const merged = { ...userValue };
+        for (const [key, value] of Object.entries(repoValue)) {
+            merged[key] = mergeValues(userValue[key], value);
+        }
+        return merged;
+    }
+    return repoValue;
+}
+export function mergeConfigFiles(userConfig, repoConfig) {
+    if (!userConfig && !repoConfig)
+        return undefined;
+    if (!userConfig)
+        return repoConfig;
+    if (!repoConfig)
+        return userConfig;
+    return mergeValues(userConfig, repoConfig);
+}
+//# sourceMappingURL=merge.js.map

package/dist/core/config/paths.js

@@ -1,4 +1,11 @@
-import { join, resolve } from 'path';
+import { homedir } from 'os';
+import { defaultPathAdapter } from '../adapters/path/path-adapter.js';
+function resolveUserConfigHome() {
+    const override = (process.env.SALMONLOOP_USER_CONFIG_HOME || '').trim();
+    if (override)
+        return defaultPathAdapter.resolve(override);
+    return homedir();
+}
 /**
  * Repo-local configuration lives under ".salmonloop/" and is expected to be gitignored.
  * Runtime state is stored under ".salmonloop/runtime/" (audit, rejections, tmp, locks).
@@ -7,14 +14,26 @@ export function getDefaultRepoConfigPath(repoRoot) {
     return getDefaultRepoConfigPaths(repoRoot)[0];
 }
 export function getDefaultRepoConfigPaths(repoRoot) {
-    const base = join(resolve(repoRoot), '.salmonloop', 'config');
-    return [join(base, 'config.yaml'), join(base, 'config.yml'), join(base, 'config.json')];
+    const base = defaultPathAdapter.join(defaultPathAdapter.resolve(repoRoot), '.salmonloop', 'config');
+    return [
+        defaultPathAdapter.join(base, 'config.yaml'),
+        defaultPathAdapter.join(base, 'config.yml'),
+        defaultPathAdapter.join(base, 'config.json'),
+    ];
+}
+export function getDefaultUserConfigPaths() {
+    const base = defaultPathAdapter.join(resolveUserConfigHome(), '.salmonloop', 'config');
+    return [
+        defaultPathAdapter.join(base, 'config.yaml'),
+        defaultPathAdapter.join(base, 'config.yml'),
+        defaultPathAdapter.join(base, 'config.json'),
+    ];
 }
 export function resolveConfigPath(repoRoot, configPath) {
     // Relative paths are resolved against the target repo root (not the CLI's cwd).
-    return resolve(repoRoot, configPath);
+    return defaultPathAdapter.resolve(repoRoot, configPath);
 }
 export function getDefaultIndexPath(repoRoot) {
-    return join(resolve(repoRoot), '.salmonloop', 'index');
+    return defaultPathAdapter.join(defaultPathAdapter.resolve(repoRoot), '.salmonloop', 'index');
 }
 //# sourceMappingURL=paths.js.map

package/dist/core/config/resolve.js

@@ -1,5 +1,6 @@
 import { resolveLlmOutputPolicy } from '../llm/output-policy.js';
-import { tryLoadConfigFile } from './load.js';
+import { loadConfigStack } from './load.js';
+import { mergeConfigFiles } from './merge.js';
 import { getDefaultRepoConfigPath } from './paths.js';
 import { resolveLlmFromConfig } from './resolve-llm.js';
 import { resolveAstValidationStrictness } from './resolvers/ast-validation.js';
@@ -15,20 +16,21 @@ export async function resolveConfig(opts) {
     const enabled = opts.enableConfigFile !== false;
     const path = opts.configFilePath;
     const required = Boolean(opts.configFilePath);
-    const loaded = await tryLoadConfigFile({
+    const loaded = await loadConfigStack({
         repoRoot: opts.repoRoot,
         configPath: path,
         enabled,
         required,
     });
-    const raw = loaded?.config;
+    const raw = mergeConfigFiles(loaded.user?.config, loaded.repo?.config);
     const uiLogMode = resolveUiLogMode(raw);
     const permissionMode = resolvePermissionMode(raw);
+    const sourcePath = loaded.repo?.path || loaded.user?.path || path || getDefaultRepoConfigPath(opts.repoRoot);
     return {
         source: {
             enabled,
-            path: loaded?.path || path || getDefaultRepoConfigPath(opts.repoRoot),
-            used: Boolean(loaded),
+            path: sourcePath,
+            used: Boolean(loaded.repo || loaded.user),
         },
         raw,
         permissionMode,

package/dist/core/config/validate.js

@@ -471,6 +471,27 @@ export function validateConfigFileV1(input) {
         }
         if (input.llm.activeModel !== undefined)
             cfg.llm.activeModel = input.llm.activeModel;
+        const llmAny = input.llm;
+        if (llmAny.simpleModel !== undefined && !isString(llmAny.simpleModel)) {
+            throw new ConfigError('CONFIG_INVALID_LLM_SIMPLE_MODEL', { expected: 'string' });
+        }
+        if (llmAny.simpleModel !== undefined)
+            cfg.llm.simpleModel = llmAny.simpleModel;
+        if (llmAny.mediumModel !== undefined && !isString(llmAny.mediumModel)) {
+            throw new ConfigError('CONFIG_INVALID_LLM_MEDIUM_MODEL', { expected: 'string' });
+        }
+        if (llmAny.mediumModel !== undefined)
+            cfg.llm.mediumModel = llmAny.mediumModel;
+        if (llmAny.complexModel !== undefined && !isString(llmAny.complexModel)) {
+            throw new ConfigError('CONFIG_INVALID_LLM_COMPLEX_MODEL', { expected: 'string' });
+        }
+        if (llmAny.complexModel !== undefined)
+            cfg.llm.complexModel = llmAny.complexModel;
+        if (llmAny.reasoningModel !== undefined && !isString(llmAny.reasoningModel)) {
+            throw new ConfigError('CONFIG_INVALID_LLM_REASONING_MODEL', { expected: 'string' });
+        }
+        if (llmAny.reasoningModel !== undefined)
+            cfg.llm.reasoningModel = llmAny.reasoningModel;
         if (input.llm.providers !== undefined) {
             if (!isRecord(input.llm.providers)) {
                 throw new ConfigError('CONFIG_INVALID_LLM_PROVIDERS', { expected: 'object' });

package/dist/core/facades/cli-command-chat.js

@@ -1,4 +1,4 @@
-export { normalizePermissionMode, resolveConfig } from '../config/index.js';
+export { ConfigError, normalizePermissionMode, resolveConfig } from '../config/index.js';
 export { ExtensionConfigError, resolveExtensions } from '../extensions/index.js';
 export { createRuntimeLlm } from '../llm/factory.js';
 export { getLogger } from '../observability/logger.js';

package/dist/core/facades/cli-context.js

@@ -1,4 +1,5 @@
 export { defaultPathAdapter } from '../adapters/path/path-adapter.js';
+export { ConfigError } from '../config/index.js';
 export { resolveConfig } from '../config/resolve.js';
 export { createContextCacheStore } from '../context/cache/store-factory.js';
 export { ContextService } from '../context/index.js';

package/dist/core/grizzco/engine/transaction/transaction-runner.js

@@ -1,4 +1,5 @@
 import { recordAuditEvent } from '../../../observability/audit-trail.js';
+import { mapErrorForAudit } from '../../../observability/error-mapping.js';
 import { ReflectionEngine } from '../../../reflection/engine.js';
 import { executeSalmonLoopFlow } from '../../flows/SalmonLoopFlow.js';
 import { resolveAttemptFailure } from './attempt-failure.js';
@@ -120,6 +121,10 @@ export class FlowTransactionRunner {
                     timestamp: this.params.now(),
                 });
             }
+            const mappedAuditError = mapErrorForAudit({
+                message: attemptFailure.safeHint ?? attemptFailure.reason,
+                code: attemptFailure.errorCode ?? attemptFailure.reasonCode,
+            });
             recordAuditEvent('loop.attempt.failure', {
                 attempt,
                 flowMode: this.params.flowMode,
@@ -131,6 +136,9 @@ export class FlowTransactionRunner {
                 failurePhase: attemptFailure.failurePhase,
                 retryable: attemptFailure.retryable,
                 errorCode: attemptFailure.errorCode,
+                errorSummary: mappedAuditError.summary,
+                errorCategory: mappedAuditError.category,
+                errorRedacted: mappedAuditError.redacted,
                 lastStep: result.lastStep,
             }, {
                 phase: attemptFailure.failurePhase,

package/dist/core/grizzco/steps/preflight.js

@@ -6,7 +6,10 @@ import { preflight } from '../../verification/runner.js';
 import { resolveLlmToolCallingPolicy } from '../dsl/llm-strategy.js';
 export const runPreflight = async (ctx) => {
     const result = await preflight(ctx.workspace, ctx.emit, {
-        ignoreDirty: ctx.mode === 'review' || ctx.mode === 'research' || ctx.mode === 'answer',
+        ignoreDirty: ctx.mode === 'review' ||
+            ctx.mode === 'research' ||
+            ctx.mode === 'answer' ||
+            ctx.options.permissionMode === 'yolo',
     });
     if (!result.ok) {
         const reason = result.reason || text.loop.preflightFailedNotGit;

package/dist/core/intent/chat-intent.js

@@ -64,10 +64,6 @@ function routeHeuristic(input) {
         'research',
         'investigate',
         'investigation',
-        '调研',
-        '研究',
-        '资料搜集',
-        '资料收集',
     ];
     if (researchSignals.some((s) => lower.includes(s))) {
         return {

package/dist/core/llm/ai-sdk/request-params.js

@@ -4,7 +4,7 @@ export function buildAiSdkRequestParams(params) {
         messages: params.messages,
         tools: params.tools,
         temperature: params.options.temperature,
-        maxOutputTokens: params.options.maxTokens,
+        maxOutputTokens: params.options.maxTokens != null ? Number(params.options.maxTokens) : undefined,
         stopSequences: params.options.stop,
         toolChoice: (params.options.toolChoice === 'none'
             ? 'none'

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

@@ -1,4 +1,5 @@
 import { InMemoryTaskStore } from '@a2a-js/sdk/server';
+import { buildCanonicalExecutionRequest, buildInstructionFromParts, } from '../../shared/execution-request.js';
 export function createA2AInteractionExecutor(deps) {
     const store = deps.taskStore ?? new InMemoryTaskStore();
     const metadataByTaskId = new Map();
@@ -41,12 +42,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 +218,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/acp/formal-agent.js

@@ -7,6 +7,7 @@ import { inferTurnStopReasonFromFailure } from '../../interaction/turn-stop-reas
 import { recordAuditEvent } from '../../observability/audit-trail.js';
 import { readPlan } from '../../plan/index.js';
 import { parseSlashInput } from '../../slash/parser.js';
+import { buildCanonicalExecutionRequest } from '../shared/execution-request.js';
 import { createAcpCommandRunner } from './acp-command-runner.js';
 import { createAcpFileSystem } from './acp-filesystem.js';
 import { createAcpSessionStore, isTerminalTaskEvent } from './handlers.js';
@@ -52,6 +53,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,11 +82,6 @@ function buildJsonResourceContentBlock(data) {
         },
     };
 }
-const defaultPromptCapabilities = {
-    image: false,
-    audio: false,
-    embeddedContext: false,
-};
 const ACP_AVAILABLE_COMMANDS = [
     { name: 'help', description: text.acp.slashHelpDescription },
 ];
@@ -294,12 +300,42 @@ function buildAvailableCommandsUpdateIfChanged(state) {
         availableCommands,
     };
 }
+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 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,
+            },
+        ],
+    };
+}
 function buildCurrentModeUpdateIfChanged(state) {
     const digest = state.modeId;
     if (digest === state.lastModeDigest)
@@ -326,6 +362,7 @@ function createSessionRuntimeStateFromPersisted(input) {
         lastCommandsDigest: null,
         lastConfigDigest: null,
         lastModeDigest: null,
+        lastSessionInfoDigest: null,
         permissionPolicy,
         modeId,
     };
@@ -456,6 +493,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,
@@ -779,6 +825,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;
@@ -846,14 +907,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 +935,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 +968,7 @@ export function createAcpFormalAgent(deps) {
             return {
                 sessionId: session.id,
                 configOptions: buildConfigOptions(runtimeState),
+                modes: buildModesState(runtimeState.modeId),
                 ...(sessionMeta ? { _meta: sessionMeta } : {}),
             };
         },
@@ -902,8 +977,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 +1017,7 @@ export function createAcpFormalAgent(deps) {
             }
             const response = {
                 configOptions: buildConfigOptions(runtimeState),
+                modes: buildModesState(runtimeState.modeId),
             };
             if (deps.checkpointReader) {
                 const startedAt = Date.now();
@@ -1019,6 +1105,7 @@ export function createAcpFormalAgent(deps) {
             }
             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 +1116,26 @@ 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);
+            if (!isSessionModeId(params.modeId)) {
+                throw new RequestError(-32602, `Invalid params: unsupported modeId "${params.modeId}"`);
+            }
+            runtimeState.modeId = params.modeId;
+            sessions.update(params.sessionId, (current) => ({ ...current }));
+            await persistSessionsBestEffort();
+            await emitSessionInfoUpdateBestEffort(params.sessionId);
+            // 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 +1146,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 +1167,7 @@ export function createAcpFormalAgent(deps) {
                 };
             });
             await persistSessionsBestEffort();
+            await emitSessionInfoUpdateBestEffort(params.sessionId);
             const configUpdate = buildConfigOptionUpdateIfChanged(runtimeState);
             if (configUpdate) {
                 await emitSessionUpdate(params.sessionId, configUpdate);
@@ -1083,16 +1199,23 @@ export function createAcpFormalAgent(deps) {
                         ],
                     }));
                     await persistSessionsBestEffort();
+                    await emitSessionInfoUpdateBestEffort(params.sessionId);
                     return { stopReason: 'end_turn' };
                 }
             }
-            const { task, signal } = await deps.facade.createTask({
+            // Check for cancellation again before creating task
+            if (sessions.get(params.sessionId)?.cancelRequested === true) {
+                return { stopReason: 'cancelled' };
+            }
+            const pendingUpdates = [];
+            const executionRequest = buildCanonicalExecutionRequest({
                 capability: 'patch',
-                request: {
-                    instruction: promptText,
-                    checkpointSessionId: params.sessionId,
-                    repoPath: session.cwd,
-                },
+                instruction: promptText,
+                checkpointSessionId: params.sessionId,
+                repoPath: session.cwd,
+            });
+            const { task, signal } = await deps.facade.createTask({
+                ...executionRequest,
                 commandRunner: effectiveExecutionBinding === 'client'
                     ? createAcpCommandRunner({ conn: deps.conn, sessionId: params.sessionId })
                     : undefined,
@@ -1109,14 +1232,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 +1308,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 +1326,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 () => { },