salmon-loop 0.2.13 → 0.2.16

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,6 +89,15 @@ 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}` : '';
@@ -230,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 [
@@ -255,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,
+            })),
         },
     ];
 }
@@ -313,27 +323,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 +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,
@@ -546,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),
                 })),
             };
         }
@@ -757,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,
                         }));
@@ -894,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;
     }
@@ -1095,10 +1104,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 +1136,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 +1232,7 @@ export function createAcpFormalAgent(deps) {
             }
             const pendingUpdates = [];
             const executionRequest = buildCanonicalExecutionRequest({
-                capability: 'patch',
+                capability: runtimeState.modeId,
                 instruction: promptText,
                 checkpointSessionId: params.sessionId,
                 repoPath: session.cwd,

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

package/dist/core/public-capabilities/flow-mode-metadata.js

@@ -0,0 +1,39 @@
+export const FLOW_MODE_PUBLIC_METADATA = {
+    autopilot: {
+        publicTitle: 'Autopilot',
+        a2aTitle: 'Autopilot',
+        acpName: 'Autopilot',
+        description: 'Let the agent decide which actions and tools to use.',
+    },
+    patch: {
+        publicTitle: 'Patch code',
+        a2aTitle: 'Patch code',
+        acpName: 'Patch',
+        description: 'Apply code changes with verification.',
+    },
+    review: {
+        publicTitle: 'Review code',
+        a2aTitle: 'Review code',
+        acpName: 'Review',
+        description: 'Inspect code and report findings without mutating files.',
+    },
+    debug: {
+        publicTitle: 'Debug issue',
+        a2aTitle: 'Debug issue',
+        acpName: 'Debug',
+        description: 'Investigate issues and make targeted fixes when needed.',
+    },
+    research: {
+        publicTitle: 'Research request',
+        a2aTitle: 'Research request',
+        acpName: 'Research',
+        description: 'Explore the codebase and summarize relevant findings.',
+    },
+    answer: {
+        publicTitle: 'Answer question',
+        a2aTitle: 'Answer question',
+        acpName: 'Answer',
+        description: 'Answer questions directly without editing files.',
+    },
+};
+//# sourceMappingURL=flow-mode-metadata.js.map

package/dist/core/public-capabilities/projections.js

@@ -0,0 +1,29 @@
+import { FLOW_MODE_PUBLIC_METADATA } from './flow-mode-metadata.js';
+import { buildPublicCapabilityRegistry } from './registry.js';
+export function selectPublicCapabilitiesForSurface(surface, entries = buildPublicCapabilityRegistry()) {
+    return entries.filter((entry) => entry.reachability === 'reachable' && entry.surfaces[surface]);
+}
+function isFlowModeCapability(entry) {
+    return entry.kind === 'flow_mode';
+}
+export function toAcpPublicModes(entries = buildPublicCapabilityRegistry()) {
+    return selectPublicCapabilitiesForSurface('acp', entries)
+        .filter(isFlowModeCapability)
+        .map((entry) => ({
+        id: entry.target,
+        name: FLOW_MODE_PUBLIC_METADATA[entry.target].acpName,
+        description: entry.description,
+    }));
+}
+export function toA2APublicSkills(entries = buildPublicCapabilityRegistry()) {
+    return selectPublicCapabilitiesForSurface('a2a', entries).map((entry) => ({
+        id: entry.id,
+        title: entry.title,
+        description: entry.description,
+        tags: entry.tags,
+        examples: entry.examples,
+        inputModes: entry.inputModes,
+        outputModes: entry.outputModes,
+    }));
+}
+//# sourceMappingURL=projections.js.map

package/dist/core/public-capabilities/registry.js

@@ -0,0 +1,26 @@
+import { FLOW_MODES } from '../types/flow-mode.js';
+import { FLOW_MODE_PUBLIC_METADATA } from './flow-mode-metadata.js';
+function getFlowModeSurfaces(mode) {
+    if (mode === 'autopilot') {
+        return {
+            a2a: true,
+            acp: true,
+        };
+    }
+    return {
+        a2a: false,
+        acp: true,
+    };
+}
+export function buildPublicCapabilityRegistry() {
+    return FLOW_MODES.map((mode) => ({
+        id: mode,
+        kind: 'flow_mode',
+        target: mode,
+        title: FLOW_MODE_PUBLIC_METADATA[mode].publicTitle,
+        description: FLOW_MODE_PUBLIC_METADATA[mode].description,
+        surfaces: getFlowModeSurfaces(mode),
+        reachability: 'reachable',
+    }));
+}
+//# sourceMappingURL=registry.js.map

package/dist/core/public-capabilities/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/core/runtime/agent-server-runtime.js

@@ -3,7 +3,6 @@ import { createTaskEventBus } from '../interaction/events/bus.js';
 import { createInteractionFacade } from '../interaction/orchestration/facade.js';
 import { createA2AInteractionExecutor } from '../protocols/a2a/sdk/executor.js';
 import { createA2ASdkExpressApp } from '../protocols/a2a/sdk/server.js';
-import { createSidecarFastifyPlugin, } from './sidecar-fastify-plugin.js';
 export function createAgentServerRuntime(deps) {
     const eventBus = deps.a2a.eventBus ?? createTaskEventBus();
     const taskStore = deps.a2a.taskStore ?? new InMemoryTaskStore();
@@ -20,67 +19,72 @@ export function createAgentServerRuntime(deps) {
         taskEventBus: eventBus,
         taskStore,
     });
-    const agentCard = deps.a2a.buildAgentCard();
-    const a2aApp = createA2ASdkExpressApp({
-        agentCard,
+    const a2aServer = (deps.createA2AServerApp ?? createA2ASdkExpressApp)({
+        agentCard: deps.a2a.buildAgentCard(),
         agentExecutor: executor,
         taskStore,
         userBuilder: deps.a2a.userBuilder,
         authMiddleware: deps.a2a.authMiddleware,
     });
-    const sidecarPlugin = createSidecarFastifyPlugin({
-        routes: deps.sidecar.routes,
-        scope: deps.listen.sidecar.type === 'tcp' ? 'tcp' : 'uds',
-        allowConditional: deps.sidecar.allowConditional,
-        authorize: deps.sidecar.authorize,
-        baseUrl: deps.sidecar.baseUrl,
-    });
-    const sidecarServer = deps.createFastify();
     let a2aServerInstance = null;
-    let sidecarServerInstance = null;
     let started = false;
+    let starting = false;
     async function start() {
-        if (started) {
+        if (started || starting) {
             throw new Error('Runtime already started');
         }
-        if (deps.configureA2A) {
-            await deps.configureA2A(a2aApp);
-        }
-        if (deps.configureSidecar) {
-            await deps.configureSidecar(sidecarServer);
-        }
-        await sidecarServer.register(sidecarPlugin);
-        a2aServerInstance = await new Promise((resolve, reject) => {
-            const server = a2aApp.listen(deps.listen.a2a.port, deps.listen.a2a.host ?? '0.0.0.0', (err) => {
-                if (err)
-                    reject(err);
-                else
+        starting = true;
+        try {
+            if (deps.configureA2A) {
+                await deps.configureA2A(a2aServer);
+            }
+            a2aServerInstance = await new Promise((resolve, reject) => {
+                const server = a2aServer.listen(deps.listen.a2a.port, deps.listen.a2a.host ?? '0.0.0.0');
+                const cleanup = () => {
+                    server.off('error', onError);
+                    server.off('listening', onListening);
+                };
+                const onError = (error) => {
+                    cleanup();
+                    reject(error);
+                };
+                const onListening = () => {
+                    cleanup();
                     resolve(server);
+                };
+                server.once('error', onError);
+                server.once('listening', onListening);
             });
-        });
-        const sidecarListenOpts = deps.listen.sidecar.type === 'tcp'
-            ? { port: deps.listen.sidecar.port, host: deps.listen.sidecar.host }
-            : { path: deps.listen.sidecar.path };
-        sidecarServerInstance = await sidecarServer.listen(sidecarListenOpts);
-        started = true;
-    }
-    async function close() {
-        if (a2aServerInstance) {
-            await new Promise((resolve) => {
-                a2aServerInstance.close(() => resolve());
-            });
+            started = true;
+        }
+        catch (error) {
             a2aServerInstance = null;
+            throw error;
+        }
+        finally {
+            starting = false;
         }
-        if (sidecarServerInstance) {
-            await sidecarServer.close();
-            sidecarServerInstance = null;
+    }
+    async function close() {
+        if (!a2aServerInstance) {
+            started = false;
+            return;
         }
+        await new Promise((resolve, reject) => {
+            a2aServerInstance.close((error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve();
+            });
+        });
+        a2aServerInstance = null;
         started = false;
     }
     return {
         eventBus,
-        a2aServer: a2aApp,
-        sidecarServer,
+        a2aServer,
         start,
         close,
     };

package/dist/core/runtime/execution-profile.js

@@ -0,0 +1,67 @@
+import { Phase } from '../types/runtime.js';
+const RECIPE_ENTRY_PHASE = Phase.PLAN;
+const RECIPE_PROFILES = {
+    patch: {
+        mode: 'patch',
+        driver: 'recipe',
+        readOnly: false,
+        ignoreDirtyPreflight: false,
+        failurePolicy: 'rollback',
+        verifyPolicy: 'required_before_success_if_mutated',
+        entryPhase: RECIPE_ENTRY_PHASE,
+    },
+    review: {
+        mode: 'review',
+        driver: 'recipe',
+        readOnly: true,
+        ignoreDirtyPreflight: true,
+        failurePolicy: 'rollback',
+        verifyPolicy: 'never',
+        entryPhase: RECIPE_ENTRY_PHASE,
+    },
+    debug: {
+        mode: 'debug',
+        driver: 'recipe',
+        readOnly: false,
+        ignoreDirtyPreflight: false,
+        failurePolicy: 'rollback',
+        verifyPolicy: 'required_before_success_if_mutated',
+        entryPhase: RECIPE_ENTRY_PHASE,
+    },
+    research: {
+        mode: 'research',
+        driver: 'recipe',
+        readOnly: true,
+        ignoreDirtyPreflight: true,
+        failurePolicy: 'rollback',
+        verifyPolicy: 'never',
+        entryPhase: RECIPE_ENTRY_PHASE,
+    },
+    answer: {
+        mode: 'answer',
+        driver: 'recipe',
+        readOnly: true,
+        ignoreDirtyPreflight: true,
+        failurePolicy: 'rollback',
+        verifyPolicy: 'never',
+        entryPhase: RECIPE_ENTRY_PHASE,
+    },
+};
+const AUTOPILOT_PROFILE = {
+    mode: 'autopilot',
+    driver: 'agent',
+    readOnly: false,
+    defaultPermissionMode: 'yolo',
+    defaultCheckpointStrategy: 'direct',
+    ignoreDirtyPreflight: true,
+    failurePolicy: 'preserve',
+    verifyPolicy: 'required_before_success_if_mutated',
+    entryPhase: Phase.AUTOPILOT,
+};
+export function resolveExecutionProfile(mode) {
+    if (mode === 'autopilot') {
+        return AUTOPILOT_PROFILE;
+    }
+    return RECIPE_PROFILES[mode];
+}
+//# sourceMappingURL=execution-profile.js.map