@jungjaehoon/mama-os 0.20.0 → 0.21.0

package/dist/cli/commands/start.js

@@ -45,6 +45,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveCodeActToolPolicy = deriveCodeActToolPolicy;
+exports.resolveCodeActAgentPolicy = resolveCodeActAgentPolicy;
+exports.resolveCodeActRawConnectors = resolveCodeActRawConnectors;
+exports.resolveCodeActMemoryScopes = resolveCodeActMemoryScopes;
+exports.bindCodeActParentModelRun = bindCodeActParentModelRun;
+exports.finalizeCodeActParentModelRun = finalizeCodeActParentModelRun;
+exports.failCodeActParentModelRun = failCodeActParentModelRun;
+exports.buildSystemAgentProcessDefaults = buildSystemAgentProcessDefaults;
 exports.startCommand = startCommand;
 exports.runAgentLoop = runAgentLoop;
 const config_manager_js_1 = require("../config/config-manager.js");
@@ -52,10 +60,12 @@ const pid_manager_js_1 = require("../utils/pid-manager.js");
 const stop_js_1 = require("./stop.js");
 const index_js_1 = require("../../auth/index.js");
 const gateway_tool_executor_js_1 = require("../../agent/gateway-tool-executor.js");
+const context_compile_service_js_1 = require("../../agent/context-compile-service.js");
 const index_js_2 = require("../../gateways/index.js");
 const graph_api_js_1 = require("../../api/graph-api.js");
 const sqlite_js_1 = __importDefault(require("../../sqlite.js"));
 const node_fs_1 = require("node:fs");
+const minimatch_1 = require("minimatch");
 const ui_command_handler_js_1 = require("../../api/ui-command-handler.js");
 const agent_store_js_1 = require("../../db/agent-store.js");
 const store_js_1 = require("../../validation/store.js");
@@ -75,16 +85,20 @@ const api_routes_init_js_1 = require("../runtime/api-routes-init.js");
 const server_start_js_1 = require("../runtime/server-start.js");
 const shutdown_js_1 = require("../runtime/shutdown.js");
 const envelope_bootstrap_js_1 = require("../runtime/envelope-bootstrap.js");
+const message_router_config_js_1 = require("../runtime/message-router-config.js");
 const reactive_config_js_1 = require("../../envelope/reactive-config.js");
 const scope_context_js_1 = require("../../memory/scope-context.js");
 const types_js_1 = require("../config/types.js");
+const role_manager_js_1 = require("../../agent/role-manager.js");
 const node_crypto_1 = require("node:crypto");
 const debugLogger = __importStar(require("@jungjaehoon/mama-core/debug-logger"));
+const mama_core_1 = require("@jungjaehoon/mama-core");
 const { DebugLogger } = debugLogger;
 const codeActLogger = new DebugLogger('CodeAct');
 const TRUTHY_ENV_VALUES = new Set(['1', 'true', 'yes', 'on']);
 const CODE_ACT_MUTATION_TOOLS = new Set([
     'mama_save',
+    'context_compile',
     'mama_update',
     'mama_add',
     'mama_ingest',
@@ -94,6 +108,210 @@ const CODE_ACT_MUTATION_TOOLS = new Set([
 function isTruthyEnvValue(value) {
     return value !== undefined && TRUTHY_ENV_VALUES.has(value.trim().toLowerCase());
 }
+function uniqueToolList(values) {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}
+function isWildcardToolList(values) {
+    return Boolean(values?.includes('*'));
+}
+function isGlobToolPattern(value) {
+    return /[*?[{]/.test(value);
+}
+function toolPatternAllows(pattern, toolName) {
+    return (0, minimatch_1.minimatch)(toolName, pattern);
+}
+function intersectAllowedToolPolicies(configuredAllowed, requestedAllowed) {
+    const configured = configuredAllowed !== undefined ? uniqueToolList(configuredAllowed) : undefined;
+    const requested = requestedAllowed !== undefined ? uniqueToolList(requestedAllowed) : undefined;
+    // Treat explicit empty arrays as deny-all so a caller cannot widen a fully
+    // restricted policy by sending a wildcard. Only an undefined (truly absent)
+    // policy falls back to the other side.
+    if (configured === undefined) {
+        return requested;
+    }
+    if (requested === undefined) {
+        return configured;
+    }
+    if (isWildcardToolList(configured)) {
+        return requested;
+    }
+    if (isWildcardToolList(requested)) {
+        return configured;
+    }
+    const narrowed = [];
+    for (const requestedPattern of requested) {
+        for (const configuredPattern of configured) {
+            if (requestedPattern === configuredPattern) {
+                narrowed.push(requestedPattern);
+            }
+            else if (!isGlobToolPattern(requestedPattern) &&
+                toolPatternAllows(configuredPattern, requestedPattern)) {
+                narrowed.push(requestedPattern);
+            }
+            else if (!isGlobToolPattern(configuredPattern) &&
+                toolPatternAllows(requestedPattern, configuredPattern)) {
+                narrowed.push(configuredPattern);
+            }
+        }
+    }
+    return uniqueToolList(narrowed);
+}
+function mergeBlockedToolPolicies(configuredBlocked, requestedBlocked) {
+    const merged = uniqueToolList([...(configuredBlocked ?? []), ...(requestedBlocked ?? [])]);
+    return merged.length > 0 ? merged : undefined;
+}
+function deriveCodeActToolPolicy(requestContext, agentConfig) {
+    const configuredAllowed = agentConfig?.gateway_tool_permissions?.allowed ?? agentConfig?.tool_permissions?.allowed;
+    const configuredBlocked = agentConfig?.gateway_tool_permissions?.blocked ?? agentConfig?.tool_permissions?.blocked;
+    const allowedTools = intersectAllowedToolPolicies(configuredAllowed, requestContext?.allowedTools);
+    const blockedTools = mergeBlockedToolPolicies(configuredBlocked, requestContext?.blockedTools);
+    return { allowedTools, blockedTools };
+}
+function resolveCodeActAgentPolicy(requestContext, agents, defaultAgentId) {
+    const agentId = requestContext?.agentId || defaultAgentId;
+    const agentConfig = agents?.[agentId];
+    if (!agentConfig) {
+        return { agentId, error: `Unknown Code-Act agent: ${agentId}` };
+    }
+    if (agentConfig.useCodeAct !== true) {
+        return { agentId, error: `Agent is not configured for Code-Act: ${agentId}` };
+    }
+    const policy = deriveCodeActToolPolicy(requestContext, agentConfig);
+    if (!policy.allowedTools || policy.allowedTools.length === 0) {
+        // Fail closed: an agent that resolves to no allowed tools must be rejected
+        // rather than silently widened to wildcard access.
+        return {
+            agentId,
+            agentConfig,
+            policy,
+            error: `Agent has no allowed Code-Act tools: ${agentId}`,
+        };
+    }
+    return {
+        agentId,
+        agentConfig,
+        policy,
+    };
+}
+function resolveCodeActRawConnectors(enabledConnectorNames) {
+    return [...new Set((enabledConnectorNames ?? []).map((name) => name.trim()).filter(Boolean))];
+}
+const CODE_ACT_RAW_MEMORY_SCOPE_LIMIT = 500;
+const MEMORY_SCOPE_KINDS = new Set(['global', 'user', 'channel', 'project']);
+function isMemoryScopeKind(value) {
+    return typeof value === 'string' && MEMORY_SCOPE_KINDS.has(value);
+}
+function uniqueMemoryScopes(scopes) {
+    const seen = new Set();
+    const unique = [];
+    for (const scope of scopes) {
+        const id = scope.id.trim();
+        if (!id) {
+            continue;
+        }
+        const key = `${scope.kind}:${id}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        unique.push({ kind: scope.kind, id });
+    }
+    return unique;
+}
+function resolveCodeActMemoryScopes(baseScopes, adapter) {
+    const scopes = [...baseScopes];
+    if (!adapter) {
+        return uniqueMemoryScopes(scopes);
+    }
+    try {
+        const rows = adapter
+            .prepare(`
+          SELECT DISTINCT ms.kind AS kind, ms.external_id AS id
+          FROM memory_scopes ms
+          JOIN memory_scope_bindings msb ON msb.scope_id = ms.id
+          JOIN decisions d ON d.id = msb.memory_id
+          WHERE d.topic LIKE 'raw/%'
+            AND (d.status = 'active' OR d.status IS NULL)
+            AND d.superseded_by IS NULL
+          ORDER BY ms.kind, ms.external_id
+          LIMIT ?
+        `)
+            .all(CODE_ACT_RAW_MEMORY_SCOPE_LIMIT);
+        for (const row of rows) {
+            if (!isMemoryScopeKind(row.kind) || typeof row.id !== 'string') {
+                continue;
+            }
+            scopes.push({ kind: row.kind, id: row.id });
+        }
+    }
+    catch {
+        return uniqueMemoryScopes(scopes);
+    }
+    return uniqueMemoryScopes(scopes);
+}
+function buildCodeActRole(policy) {
+    // Caller (resolveCodeActAgentPolicy) rejects empty/undefined allowedTools, so
+    // here we honor the resolved policy verbatim instead of widening to wildcard.
+    return {
+        allowedTools: policy.allowedTools ?? [],
+        blockedTools: policy.blockedTools,
+        allowedPaths: [],
+        systemControl: false,
+        sensitiveAccess: false,
+    };
+}
+function bindCodeActParentModelRun(adapter, executionContext, options) {
+    if (!executionContext?.envelope) {
+        return { executionContext, modelRunId: null };
+    }
+    const run = (0, mama_core_1.beginModelRunInAdapter)(adapter, {
+        agent_id: executionContext.agentId,
+        instance_id: executionContext.envelope.instance_id,
+        envelope_hash: executionContext.envelope.envelope_hash,
+        input_snapshot_ref: options.inputSnapshotRef,
+        input_refs: options.inputRefs,
+    });
+    return {
+        executionContext: {
+            ...executionContext,
+            modelRunId: run.model_run_id,
+        },
+        modelRunId: run.model_run_id,
+    };
+}
+function codeActErrorSummary(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+function resultErrorSummary(result) {
+    if (typeof result.error === 'string') {
+        return result.error;
+    }
+    return result.error?.message ?? 'Code-Act execution failed';
+}
+function finalizeCodeActParentModelRun(adapter, modelRunId, result) {
+    if (!modelRunId) {
+        return;
+    }
+    if (result.success === false) {
+        (0, mama_core_1.failModelRunInAdapter)(adapter, modelRunId, resultErrorSummary(result));
+        return;
+    }
+    (0, mama_core_1.commitModelRunInAdapter)(adapter, modelRunId, 'code-act completed');
+}
+function failCodeActParentModelRun(adapter, modelRunId, error) {
+    if (!modelRunId) {
+        return;
+    }
+    (0, mama_core_1.failModelRunInAdapter)(adapter, modelRunId, codeActErrorSummary(error));
+}
+function buildSystemAgentProcessDefaults(config) {
+    return {
+        dangerouslySkipPermissions: config.multi_agent?.dangerouslySkipPermissions ?? true,
+    };
+}
 /**
  * Execute start command
  */
@@ -126,9 +344,11 @@ async function startCommand(options = {}) {
         console.error(`Failed to load config: ${error instanceof Error ? error.message : String(error)}\n`);
         process.exit(1);
     }
+    const validBackends = ['claude', 'codex', 'codex-mcp'];
     const backend = config.agent.backend;
-    process.env.MAMA_BACKEND = backend;
-    if (backend === 'codex-mcp') {
+    const isValidBackend = validBackends.includes(backend);
+    process.env.MAMA_BACKEND = isValidBackend ? backend : 'claude';
+    if (backend === 'codex' || backend === 'codex-mcp') {
         console.log('✓ Codex-MCP backend (OAuth handled by Codex login)');
     }
     else {
@@ -214,7 +434,9 @@ async function startCommand(options = {}) {
 async function runAgentLoop(config, options = {}) {
     // ── Phase 1: Foundation ───────────────────────────────────────────────────
     const startupBackend = config.agent.backend;
-    const usesCodexBackend = startupBackend === 'codex-mcp' || (0, utilities_js_1.hasCodexBackendConfigured)(config);
+    const usesCodexBackend = startupBackend === 'codex' ||
+        startupBackend === 'codex-mcp' ||
+        (0, utilities_js_1.hasCodexBackendConfigured)(config);
     if (usesCodexBackend) {
         const codexCommand = (0, utilities_js_1.resolveCodexCommandForStartup)();
         process.env.MAMA_CODEX_COMMAND = codexCommand;
@@ -267,30 +489,35 @@ async function runAgentLoop(config, options = {}) {
         envelopeIssuanceMode: envelopeBootstrap.metadata.issuance,
         metricsStore,
     });
-    const validBackends = ['claude', 'codex-mcp'];
+    const validBackends = ['claude', 'codex', 'codex-mcp'];
     const rawBackend = config.agent.backend;
     const isValidBackend = validBackends.includes(rawBackend);
-    const runtimeBackend = isValidBackend
-        ? rawBackend
-        : 'claude';
+    const runtimeBackend = isValidBackend ? rawBackend : 'claude';
+    process.env.MAMA_BACKEND = runtimeBackend;
     if (rawBackend && !isValidBackend) {
         console.warn(`[Config] Unknown backend "${rawBackend}", falling back to "claude"`);
-        process.env.MAMA_BACKEND = 'claude';
     }
+    const agentLoopBackend = runtimeBackend === 'codex' || runtimeBackend === 'codex-mcp' ? 'codex-mcp' : 'claude';
     // Initialize main agent loop + client (reasoning state is closure-scoped inside)
-    const { agentLoop, agentLoopClient } = (0, agent_loop_init_js_1.initMainAgentLoop)(config, oauthManager, db, metricsStore, runtimeBackend, { ...options, envelopeIssuanceMode: envelopeBootstrap.metadata.issuance });
+    const { agentLoop, agentLoopClient } = (0, agent_loop_init_js_1.initMainAgentLoop)(config, oauthManager, db, metricsStore, agentLoopBackend, {
+        ...options,
+        envelopeIssuanceMode: envelopeBootstrap.metadata.issuance,
+    });
     // ── Phase 3: MAMA Core API ────────────────────────────────────────────────
     const { mamaApi, mamaApiClient, connectorExtractionFn } = await (0, mama_core_init_js_1.initMamaCore)(config);
     // getAdapter is still used directly in this file for DB queries after initDB has run
     // eslint-disable-next-line @typescript-eslint/no-require-imports
     const { getAdapter } = require('@jungjaehoon/mama-core/db-manager');
+    const contextCompileService = (0, context_compile_service_js_1.createContextCompileService)({
+        memoryAdapter: getAdapter(),
+    });
+    toolExecutor.setContextCompileService(contextCompileService);
+    agentLoop.setContextCompileService(contextCompileService);
     // ── Phase 4: Memory Agent + MessageRouter ─────────────────────────────────
-    const messageRouter = new index_js_2.MessageRouter(sessionStore, agentLoopClient, mamaApiClient, {
-        backend: runtimeBackend,
-    }, envelopeBootstrap.envelopeConfig, envelopeBootstrap.envelopeAuthority);
+    const messageRouter = new index_js_2.MessageRouter(sessionStore, agentLoopClient, mamaApiClient, (0, message_router_config_js_1.resolveMessageRouterConfig)(config, runtimeBackend), envelopeBootstrap.envelopeConfig, envelopeBootstrap.envelopeAuthority);
     messageRouter.setSessionsDb(db);
     // validationService wired after creation (Phase 5 below)
-    const { memoryAgentLoop } = await (0, memory_agent_init_js_1.initMemoryAgent)(oauthManager, config, mamaApi, mamaApiClient, messageRouter, runtimeBackend);
+    const { memoryAgentLoop } = await (0, memory_agent_init_js_1.initMemoryAgent)(oauthManager, config, mamaApi, mamaApiClient, messageRouter, agentLoopBackend);
     // ── Phase 5: Graph Handler + Embedding ────────────────────────────────────
     // Create singleton UI command queue for Agent↔Viewer communication
     const uiCommandQueue = new ui_command_handler_js_1.UICommandQueue();
@@ -302,6 +529,7 @@ async function runAgentLoop(config, options = {}) {
         sessionsDb: db,
         uiCommandQueue,
     };
+    let codeActRawConnectors = [];
     // Wire uiCommandQueue into messageRouter for page context awareness
     messageRouter.setUICommandQueue(uiCommandQueue);
     // Wire sessionsDb and uiCommandQueue into gateway tool executor
@@ -311,113 +539,132 @@ async function runAgentLoop(config, options = {}) {
     agentLoop.setUICommandQueue(uiCommandQueue);
     // Wire up Code-Act executor for POST /api/code-act endpoint
     // Always register: Dashboard/Wiki agents use code-act via MCP → HTTP proxy
-    {
-        graphHandlerOptions.executeCodeAct = async (code) => {
-            const { CodeActSandbox, HostBridge } = await import('../../agent/code-act/index.js');
-            const sandbox = new CodeActSandbox();
-            const codeActAgentId = config.multi_agent?.default_agent || 'conductor';
-            const codeActReadOnly = isTruthyEnvValue(process.env.MAMA_CODE_ACT_READ_ONLY);
-            const codeActTier = codeActReadOnly ? 3 : 2;
-            let executionContext = null;
-            if (envelopeBootstrap.envelopeAuthority && envelopeBootstrap.metadata.issuance !== 'off') {
-                const projectId = (0, reactive_config_js_1.resolveReactiveProjectRoot)(config, process.env);
-                const projectRef = { kind: 'project', id: projectId };
-                const memoryScopes = (0, scope_context_js_1.deriveMemoryScopes)({
-                    source: 'watch',
-                    channelId: 'api:code-act',
-                    userId: 'api',
-                    projectId,
-                });
-                const instanceId = (0, node_crypto_1.randomUUID)();
-                const wallSeconds = Math.min(Math.max(Math.floor((config.timeouts?.agent_ms ?? 300_000) / 1000), 1), 300);
-                const envelope = envelopeBootstrap.envelopeAuthority.buildAndPersist({
-                    agent_id: codeActAgentId,
-                    instance_id: instanceId,
-                    source: 'watch',
-                    channel_id: 'api:code-act',
-                    trigger_context: { user_text: '<api-code-act invocation>' },
-                    scope: {
-                        project_refs: [projectRef],
-                        raw_connectors: [],
-                        memory_scopes: memoryScopes,
-                        allowed_destinations: [],
-                    },
-                    tier: codeActTier,
-                    budget: { wall_seconds: wallSeconds },
-                    expires_at: new Date(Date.now() + wallSeconds * 1000 + 30_000).toISOString(),
-                });
-                const roleName = config.roles?.sourceMapping?.watch ?? 'os_agent';
-                const role = config.roles?.definitions?.[roleName] ?? types_js_1.DEFAULT_ROLES.definitions.os_agent;
-                const agentContext = {
-                    source: 'watch',
-                    platform: 'cli',
-                    roleName,
-                    role,
-                    session: {
-                        sessionId: `api:code-act:${instanceId}`,
-                        channelId: 'api:code-act',
-                        startedAt: new Date(),
-                    },
-                    capabilities: ['code_act'],
-                    limitations: codeActReadOnly ? ['Code-Act read-only mode: memory writes disabled'] : [],
-                    tier: codeActTier,
-                    backend: 'claude',
-                };
-                executionContext = {
-                    agentContext,
-                    agentId: codeActAgentId,
-                    source: 'watch',
+    graphHandlerOptions.executeCodeAct = async (code, codeActContext) => {
+        const { CodeActSandbox, HostBridge } = await import('../../agent/code-act/index.js');
+        const sandbox = new CodeActSandbox();
+        const resolvedCodeActPolicy = resolveCodeActAgentPolicy(codeActContext, config.multi_agent?.agents, config.multi_agent?.default_agent || 'conductor');
+        if (resolvedCodeActPolicy.error) {
+            return { success: false, error: resolvedCodeActPolicy.error };
+        }
+        const codeActAgentId = resolvedCodeActPolicy.agentId;
+        const codeActPolicy = resolvedCodeActPolicy.policy ?? {};
+        const codeActRole = buildCodeActRole(codeActPolicy);
+        const codeActReadOnly = isTruthyEnvValue(process.env.MAMA_CODE_ACT_READ_ONLY);
+        const codeActTier = codeActReadOnly ? 3 : 2;
+        const instanceId = (0, node_crypto_1.randomUUID)();
+        let executionContext = null;
+        if (envelopeBootstrap.envelopeAuthority && envelopeBootstrap.metadata.issuance !== 'off') {
+            const projectId = (0, reactive_config_js_1.resolveReactiveProjectRoot)(config, process.env);
+            const projectRef = { kind: 'project', id: projectId };
+            const memoryScopes = resolveCodeActMemoryScopes((0, scope_context_js_1.deriveMemoryScopes)({
+                source: 'watch',
+                channelId: 'api:code-act',
+                userId: 'api',
+                projectId,
+            }), getAdapter());
+            const wallSeconds = Math.min(Math.max(Math.floor((config.timeouts?.agent_ms ?? 300_000) / 1000), 1), 300);
+            const envelope = envelopeBootstrap.envelopeAuthority.buildAndPersist({
+                agent_id: codeActAgentId,
+                instance_id: instanceId,
+                source: 'watch',
+                channel_id: 'api:code-act',
+                trigger_context: { user_text: '<api-code-act invocation>' },
+                scope: {
+                    project_refs: [projectRef],
+                    raw_connectors: codeActRawConnectors,
+                    memory_scopes: memoryScopes,
+                    allowed_destinations: [],
+                },
+                tier: codeActTier,
+                budget: { wall_seconds: wallSeconds },
+                expires_at: new Date(Date.now() + wallSeconds * 1000 + 30_000).toISOString(),
+            });
+            const roleName = `code_act_${codeActAgentId}`;
+            const role = codeActRole;
+            const agentContext = {
+                source: 'watch',
+                platform: 'cli',
+                roleName,
+                role,
+                session: {
+                    sessionId: `api:code-act:${instanceId}`,
                     channelId: 'api:code-act',
-                    envelope,
-                    executionSurface: 'code_act',
-                };
-            }
-            const bridge = new HostBridge(toolExecutor, undefined, executionContext);
-            const toolCalls = [];
-            bridge.onToolUse = (toolName, input, result) => {
-                if (result !== undefined) {
-                    toolCalls.push({ name: toolName, input });
-                    if (CODE_ACT_MUTATION_TOOLS.has(toolName)) {
-                        codeActLogger.warn('[CodeAct] mutation tool call', {
-                            toolName,
-                            success: Boolean(result.success),
-                            readOnly: codeActReadOnly,
-                            envelopeHash: executionContext?.envelope?.envelope_hash ?? null,
-                        });
-                    }
-                }
+                    startedAt: new Date(),
+                },
+                capabilities: ['code_act'],
+                limitations: codeActReadOnly ? ['Code-Act read-only mode: memory writes disabled'] : [],
+                tier: codeActTier,
+                backend: runtimeBackend,
             };
-            const previousRoutingContext = toolExecutor.getCurrentAgentRoutingContext();
-            try {
-                // Set default agent context for /api/code-act calls (Conductor, tiered sandbox).
-                // Per-request executionContext carries envelope data; this routing context is legacy fallback.
-                toolExecutor.setCurrentAgentContext(codeActAgentId, 'api', 'code-act');
-                bridge.injectInto(sandbox, codeActTier);
-                const result = await sandbox.execute(code);
-                return {
-                    success: result.success,
-                    value: result.value,
-                    logs: result.logs,
-                    error: result.error?.message,
-                    metrics: result.metrics,
-                    toolCalls,
-                };
-            }
-            finally {
-                toolExecutor.restoreCurrentAgentRoutingContext(previousRoutingContext);
+            executionContext = {
+                agentContext,
+                agentId: codeActAgentId,
+                source: 'watch',
+                channelId: 'api:code-act',
+                envelope,
+                executionSurface: 'code_act',
+            };
+        }
+        const parentRun = bindCodeActParentModelRun(getAdapter(), executionContext, {
+            inputSnapshotRef: `code-act:${instanceId}`,
+            inputRefs: {
+                tool: 'code_act',
+                source: 'api',
+                channel_id: 'api:code-act',
+                read_only: codeActReadOnly,
+            },
+        });
+        executionContext = parentRun.executionContext;
+        const bridge = new HostBridge(toolExecutor, new role_manager_js_1.RoleManager({ rolesConfig: config.roles ?? types_js_1.DEFAULT_ROLES }), executionContext);
+        const toolCalls = [];
+        bridge.onToolUse = (toolName, input, result) => {
+            if (result !== undefined) {
+                toolCalls.push({ name: toolName, input });
+                if (CODE_ACT_MUTATION_TOOLS.has(toolName)) {
+                    codeActLogger.warn('[CodeAct] mutation tool call', {
+                        toolName,
+                        success: Boolean(result.success),
+                        readOnly: codeActReadOnly,
+                        envelopeHash: executionContext?.envelope?.envelope_hash ?? null,
+                    });
+                }
             }
         };
-        // Pre-warm Code-Act WASM module for fast first execution
-        (async () => {
-            try {
-                const { CodeActSandbox } = await import('../../agent/code-act/index.js');
-                await CodeActSandbox.warmup();
-            }
-            catch (err) {
-                console.warn('[CodeAct] WASM warmup failed (non-fatal):', err);
-            }
-        })();
-    }
+        const previousRoutingContext = toolExecutor.getCurrentAgentRoutingContext();
+        try {
+            // Set default agent context for /api/code-act calls (Conductor, tiered sandbox).
+            // Per-request executionContext carries envelope data; this routing context is legacy fallback.
+            toolExecutor.setCurrentAgentContext(codeActAgentId, 'api', 'code-act');
+            bridge.injectInto(sandbox, codeActTier, codeActRole);
+            const result = await sandbox.execute(code);
+            finalizeCodeActParentModelRun(getAdapter(), parentRun.modelRunId, result);
+            return {
+                success: result.success,
+                value: result.value,
+                logs: result.logs,
+                error: result.error?.message,
+                metrics: result.metrics,
+                toolCalls,
+            };
+        }
+        catch (error) {
+            failCodeActParentModelRun(getAdapter(), parentRun.modelRunId, error);
+            throw error;
+        }
+        finally {
+            toolExecutor.restoreCurrentAgentRoutingContext(previousRoutingContext);
+        }
+    };
+    // Pre-warm Code-Act WASM module for fast first execution
+    (async () => {
+        try {
+            const { CodeActSandbox } = await import('../../agent/code-act/index.js');
+            await CodeActSandbox.warmup();
+        }
+        catch (err) {
+            console.warn('[CodeAct] WASM warmup failed (non-fatal):', err);
+        }
+    })();
     const graphHandler = (0, graph_api_js_1.createGraphHandler)(graphHandlerOptions);
     // Seed initial agent versions from config (version 1 for new agents)
     // initAgentTables is idempotent (CREATE IF NOT EXISTS) — safe to call before apiServer
@@ -428,83 +675,83 @@ async function runAgentLoop(config, options = {}) {
     toolExecutor.setValidationService(validationService);
     messageRouter.setValidationService(validationService);
     agentLoop.setValidationService(validationService);
-    {
-        // Ensure OS system agents exist in config (memory agent may be missing in older configs)
-        if (!config.multi_agent) {
-            config.multi_agent = (0, config_manager_js_1.getDefaultMultiAgentConfig)();
+    // Ensure current primary system agents exist in config. Legacy self-paced
+    // dashboard/wiki agents are opt-in and must not be backfilled here.
+    if (!config.multi_agent) {
+        config.multi_agent = (0, config_manager_js_1.getDefaultMultiAgentConfig)();
+    }
+    if (!config.multi_agent.agents) {
+        config.multi_agent.agents = {};
+    }
+    const osAgents = {
+        'os-agent': {
+            name: 'OS Agent',
+            display_name: '🖥️ OS Agent',
+            trigger_prefix: '!os',
+            persona_file: '~/.mama/personas/os-agent.md',
+            tier: 1,
+            backend: runtimeBackend,
+            model: config.agent.model,
+            can_delegate: true,
+            enabled: true,
+        },
+        memory: {
+            name: 'Memory Agent',
+            display_name: '🧠 Memory',
+            trigger_prefix: '!memory',
+            persona_file: '~/.mama/personas/memory.md',
+            tier: 3,
+            backend: runtimeBackend,
+            model: config.agent.model,
+            can_delegate: false,
+            enabled: true,
+        },
+    };
+    let osAgentsAdded = false;
+    for (const [id, cfg] of Object.entries(osAgents)) {
+        if (!config.multi_agent.agents[id]) {
+            config.multi_agent.agents[id] = cfg;
+            osAgentsAdded = true;
         }
-        if (!config.multi_agent.agents) {
-            config.multi_agent.agents = {};
+    }
+    // Persist to config.yaml so /api/agents sees them too
+    if (osAgentsAdded) {
+        try {
+            const { saveConfig } = await import('../config/config-manager.js');
+            await saveConfig(config);
+            console.log('✓ OS agents added to config.yaml');
         }
-        const osAgents = {
-            'os-agent': {
-                name: 'OS Agent',
-                display_name: '🖥️ OS Agent',
-                trigger_prefix: '!os',
-                persona_file: '~/.mama/personas/os-agent.md',
-                tier: 1,
-                backend: runtimeBackend,
-                model: config.agent.model,
-                can_delegate: true,
-                enabled: true,
-            },
-            memory: {
-                name: 'Memory Agent',
-                display_name: '🧠 Memory',
-                trigger_prefix: '!memory',
-                persona_file: '~/.mama/personas/memory.md',
-                tier: 3,
-                backend: runtimeBackend,
-                model: config.agent.model,
-                can_delegate: false,
-                enabled: true,
-            },
-        };
-        let osAgentsAdded = false;
-        for (const [id, cfg] of Object.entries(osAgents)) {
-            if (!config.multi_agent.agents[id]) {
-                config.multi_agent.agents[id] = cfg;
-                osAgentsAdded = true;
-            }
+        catch {
+            /* non-fatal — runtime config still has them */
         }
-        // Persist to config.yaml so /api/agents sees them too
-        if (osAgentsAdded) {
+    }
+    const agents = config.multi_agent.agents;
+    for (const [id, cfg] of Object.entries(agents)) {
+        if (!(0, agent_store_js_1.getLatestVersion)(db, id)) {
+            let personaText = null;
             try {
-                const { saveConfig } = await import('../config/config-manager.js');
-                await saveConfig(config);
-                console.log('✓ OS agents added to config.yaml');
+                const pPath = (0, config_manager_js_1.expandPath)(cfg.persona_file);
+                if ((0, node_fs_1.existsSync)(pPath))
+                    personaText = (0, node_fs_1.readFileSync)(pPath, 'utf-8');
             }
             catch {
-                /* non-fatal — runtime config still has them */
-            }
-        }
-        const agents = config.multi_agent.agents;
-        for (const [id, cfg] of Object.entries(agents)) {
-            if (!(0, agent_store_js_1.getLatestVersion)(db, id)) {
-                let personaText = null;
-                try {
-                    const pPath = (0, config_manager_js_1.expandPath)(cfg.persona_file);
-                    if ((0, node_fs_1.existsSync)(pPath))
-                        personaText = (0, node_fs_1.readFileSync)(pPath, 'utf-8');
-                }
-                catch {
-                    /* ignore */
-                }
-                (0, agent_store_js_1.createAgentVersion)(db, {
-                    agent_id: id,
-                    snapshot: { model: cfg.model, tier: cfg.tier, backend: cfg.backend },
-                    persona_text: personaText,
-                    change_note: 'Initial version (migrated from config.yaml)',
-                });
+                /* ignore */
             }
+            (0, agent_store_js_1.createAgentVersion)(db, {
+                agent_id: id,
+                snapshot: { model: cfg.model, tier: cfg.tier, backend: cfg.backend },
+                persona_text: personaText,
+                change_note: 'Initial version (migrated from config.yaml)',
+            });
         }
-        console.log(`✓ Agent versions seeded (${Object.keys(agents).length} agents)`);
     }
+    console.log(`✓ Agent versions seeded (${Object.keys(agents).length} agents)`);
     await (0, utilities_js_1.startEmbeddingServerIfAvailable)(messageRouter, sessionStore, graphHandler);
     // ── Phase 6: Cron Scheduler ───────────────────────────────────────────────
     const { scheduler, cronWorker, cronEmitter } = (0, scheduler_init_js_1.initCronScheduler)(config);
     // ── Phase 7: Gateways ────────────────────────────────────────────────────
-    const { discordGateway, slackGateway, telegramGateway, gateways } = await (0, gateway_init_js_1.initGateways)(config, messageRouter, toolExecutor, agentLoop, runtimeBackend, db);
+    const gatewayInit = await (0, gateway_init_js_1.initGateways)(config, messageRouter, toolExecutor, agentLoop, runtimeBackend, db);
+    const { discordGateway, slackGateway, telegramGateway, gateways } = gatewayInit;
     // ── Phase 8: Gateway Wiring ──────────────────────────────────────────────
     const { pluginLoader } = await (0, gateway_wiring_js_1.wireGateways)({
         config,
@@ -531,25 +778,22 @@ async function runAgentLoop(config, options = {}) {
     // If no Discord/Slack handler wired the delegate tool, create standalone
     // DelegationManager + AgentProcessManager so delegate() works from any path
     // (Viewer, Telegram, iMessage, Terminal).
-    if (!toolExecutor.hasDelegateSupport() && config.multi_agent?.enabled) {
+    const fallbackMultiAgentConfig = config.multi_agent;
+    const hasSystemRunAgents = Boolean(fallbackMultiAgentConfig?.agents?.['dashboard-agent'] ||
+        fallbackMultiAgentConfig?.agents?.['wiki-agent']);
+    if (fallbackMultiAgentConfig &&
+        !toolExecutor.getAgentProcessManager() &&
+        (fallbackMultiAgentConfig.enabled || hasSystemRunAgents)) {
         const { AgentProcessManager } = await import('../../multi-agent/agent-process-manager.js');
-        const { DelegationManager } = await import('../../multi-agent/delegation-manager.js');
-        const agentConfigs = Object.entries(config.multi_agent.agents || {}).map(([id, cfg]) => ({
-            id,
-            ...cfg,
-        }));
-        const pm = new AgentProcessManager(config.multi_agent, {}, {
+        const pm = new AgentProcessManager(fallbackMultiAgentConfig, buildSystemAgentProcessDefaults(config), {
             backend: runtimeBackend,
             model: config.agent.model,
         });
-        const dm = new DelegationManager(agentConfigs);
-        dm.setSessionsDb(db);
         toolExecutor.setAgentProcessManager(pm);
-        toolExecutor.setDelegationManager(dm);
+        agentLoop.setAgentProcessManager(pm);
         graphHandlerOptions.applyMultiAgentConfig = async (rawConfig) => {
             const nextConfig = rawConfig;
             pm.updateConfig(nextConfig);
-            dm.updateAgents(Object.entries(nextConfig.agents || {}).map(([id, cfg]) => ({ id, ...cfg })));
         };
         graphHandlerOptions.restartMultiAgentAgent = async (agentId) => {
             pm.reloadPersona(agentId);
@@ -558,15 +802,38 @@ async function runAgentLoop(config, options = {}) {
         toolExecutor.setRestartMultiAgentAgent(graphHandlerOptions.restartMultiAgentAgent);
         agentLoop.setApplyMultiAgentConfig(graphHandlerOptions.applyMultiAgentConfig);
         agentLoop.setRestartMultiAgentAgent(graphHandlerOptions.restartMultiAgentAgent);
-        // Also wire to the main AgentLoop's internal GatewayToolExecutor
-        // (MessageRouter uses agentLoop which has its own executor instance)
-        agentLoop.setAgentProcessManager(pm);
-        agentLoop.setDelegationManager(dm);
-        console.log('[start] ✓ Delegate tool wired (standalone — no Discord/Slack handler)');
+        if (fallbackMultiAgentConfig.enabled && !toolExecutor.hasDelegateSupport()) {
+            const { DelegationManager } = await import('../../multi-agent/delegation-manager.js');
+            const agentConfigs = Object.entries(fallbackMultiAgentConfig.agents || {}).map(([id, cfg]) => ({
+                id,
+                ...cfg,
+            }));
+            const dm = new DelegationManager(agentConfigs);
+            dm.setSessionsDb(db);
+            toolExecutor.setDelegationManager(dm);
+            agentLoop.setDelegationManager(dm);
+            graphHandlerOptions.applyMultiAgentConfig = async (rawConfig) => {
+                const nextConfig = rawConfig;
+                pm.updateConfig(nextConfig);
+                dm.updateAgents(Object.entries(nextConfig.agents || {}).map(([id, cfg]) => ({ id, ...cfg })));
+            };
+            toolExecutor.setApplyMultiAgentConfig(graphHandlerOptions.applyMultiAgentConfig);
+            agentLoop.setApplyMultiAgentConfig(graphHandlerOptions.applyMultiAgentConfig);
+            console.log('[start] ✓ Delegate tool wired (standalone — no Discord/Slack handler)');
+        }
+        else {
+            console.log('[start] ✓ System agent process manager wired');
+        }
     }
     // ── Phase 9: Heartbeat + Connectors ──────────────────────────────────────
     const { heartbeatScheduler, tokenKeepAlive, healthWarningInterval } = (0, scheduler_init_js_1.initHeartbeat)(config, agentLoop, discordGateway, scheduler, healthCheckService);
-    const { rawStoreForApi, enabledConnectorNames, connectorSchedulerStop } = await (0, connector_init_js_1.initConnectors)(connectorExtractionFn);
+    // M2.4 freshness: the connector sink nudges the trigger loop when a poll indexes new rows. The
+    // loop is constructed AFTER initConnectors (below), so hand initConnectors a stable forwarder now
+    // and point it at the loop once it exists. Null until then -> nudge no-ops (no loop = nothing to
+    // wake), which preserves today's behavior when MAMA_TRIGGER_LOOP is unset.
+    const triggerLoopNudge = { current: null };
+    const { rawStoreForApi, enabledConnectorNames, connectorSchedulerStop } = await (0, connector_init_js_1.initConnectors)(connectorExtractionFn, { nudge: () => triggerLoopNudge.current?.() });
+    codeActRawConnectors = resolveCodeActRawConnectors(enabledConnectorNames);
     // Inject rawStore into tool executor for agent_test connector data access
     if (rawStoreForApi) {
         toolExecutor.setRawStore(rawStoreForApi);
@@ -576,6 +843,151 @@ async function runAgentLoop(config, options = {}) {
     if (connectorSchedulerStop) {
         gateways.push({ stop: () => Promise.resolve(connectorSchedulerStop()) });
     }
+    // ── Trigger loop (M1, flag-gated, additive): agent-evolved triggers on the live stream ──
+    // Runs ONLY with MAMA_TRIGGER_LOOP=1. Placed after initConnectors (which feeds
+    // connector_event_index) and after mama-core initDB. Read-only: recall/surface/log.
+    if (process.env.MAMA_TRIGGER_LOOP === '1') {
+        // Component isolation (PR #119 review): a trigger-loop bootstrap failure (bad import,
+        // DB permission, registry constructor) must not abort the whole daemon before Phase
+        // 10/11 - the gateways/viewer/agent serve independently of this optional leg. The
+        // failure is still surfaced LOUDLY below (console.error), never swallowed silently.
+        try {
+            const { OperatorTriggerLoop } = await import('../../operator/operator-trigger-loop.js');
+            const { ConnectorDeltaRepo } = await import('../../operator/connector-delta-repo.js');
+            const { TriggerRegistry } = await import('../../operator/trigger-registry.js');
+            const { createMamaMemoryPort } = await import('../../operator/mama-memory-port.js');
+            const { askAgentCLI } = await import('../../operator/trigger-author.js');
+            const { reviewTriggerCLI } = await import('../../operator/trigger-review.js');
+            const { mkdirSync } = await import('node:fs');
+            const { dirname } = await import('node:path');
+            const { ReportScheduler, FileReportScheduleStore, parseReportHours } = await import('../../operator/report-scheduler.js');
+            const { createPersonaReportAsk, OPERATOR_REPORT_SESSION_KEY } = await import('../../operator/report-run.js');
+            const { OPERATOR_FULL_REPORT_TAG } = await import('../../operator/situation-report.js');
+            const { buildBoardPublishLines } = await import('../../operator/board-slot-instructions.js');
+            const triggerDbPath = (0, config_manager_js_1.expandPath)('~/.mama/operator/triggers.db');
+            mkdirSync(dirname(triggerDbPath), { recursive: true });
+            const triggerRegistry = new TriggerRegistry(new sqlite_js_1.default(triggerDbPath));
+            // Owner-report leg (M1.5): destination chat comes from env (~/.mama/start.sh),
+            // never source. No chat configured or no telegram gateway -> loop stays read-only.
+            const reportChatId = process.env.MAMA_TRIGGER_LOOP_REPORT_CHAT || '';
+            const reportOutput = reportChatId && telegramGateway
+                ? { send: (text) => telegramGateway.sendMessage(reportChatId, text) }
+                : undefined;
+            // Scheduled full-report leg (M2): local hours from env (~/.mama/start.sh), never source.
+            // Empty/absent -> [] -> leg off. Requires the same telegram sink as the digest leg.
+            const fullReportHours = parseReportHours(process.env.MAMA_TRIGGER_LOOP_FULL_REPORT_HOURS || '');
+            const reportScheduler = fullReportHours.length > 0 && reportOutput
+                ? new ReportScheduler(fullReportHours, new FileReportScheduleStore((0, config_manager_js_1.expandPath)('~/.mama/operator/report-schedule-state.json')))
+                : undefined;
+            const triggerLoop = new OperatorTriggerLoop({
+                delta: new ConnectorDeltaRepo(getAdapter(), (0, config_manager_js_1.expandPath)('~/.mama/operator/trigger-loop-cursors.json')),
+                memory: createMamaMemoryPort(),
+                registry: triggerRegistry,
+                askAgent: askAgentCLI,
+                // M2.2: reports go through the daemon's persona agent (system prompt, pinned model,
+                // session lanes) instead of the bare CLI - report tone comes from generation inputs.
+                // JSON tasks (authoring/review) stay on the bare CLI for reliable parsing.
+                // M3 (GAP1+GAP2): run reports in a dedicated persona session lane so the multi-turn gather
+                // loop is isolated from chat and continuous across cadences (runWithContent honors
+                // options.sessionKey - agent-loop.ts:879, no agent-loop internal change). Gateway
+                // 'model_tool' executions are envelope-gated (gateway-tool-executor.ts:252-256) and
+                // issuance defaults to 'enabled' (envelope-bootstrap.ts:28-30), so each report carries a
+                // per-run scoped envelope (mirrors the code-act issuance at start.ts:1834-1865); without it
+                // every call is denied with code 'envelope_missing'. Then audit the gateway tools the agent
+                // actually EXECUTED: a full report that executed NO gateway gather tool is logged loudly
+                // (no-fallback), and every write (mama_save) is logged (observability).
+                reportAsk: createPersonaReportAsk({
+                    issueEnvelope: envelopeBootstrap.envelopeAuthority && envelopeBootstrap.metadata.issuance !== 'off'
+                        ? async () => {
+                            const projectId = (0, reactive_config_js_1.resolveReactiveProjectRoot)(config, process.env);
+                            const wallSeconds = Math.min(Math.max(Math.floor((config.timeouts?.agent_ms ?? 300_000) / 1000), 1), 300);
+                            return envelopeBootstrap.envelopeAuthority.buildAndPersist({
+                                agent_id: 'operator-report',
+                                instance_id: (0, node_crypto_1.randomUUID)(),
+                                // 'operator' is not a member of EnvelopeSource (envelope/types.ts is a closed
+                                // union); 'watch' is the daemon-internal source used by the mirrored code-act
+                                // issuance (start.ts:1834-1865). This field is issuing-source metadata only -
+                                // enforcement authorizes on scope.memory_scopes (which cover the operator:report
+                                // run below), never on envelope.source (gateway-tool-executor.ts:1421,1511,1590).
+                                source: 'watch',
+                                channel_id: 'report',
+                                trigger_context: { user_text: '<operator scheduled report>' },
+                                scope: {
+                                    // Reads: the enabled raw connectors (kagemusha_* gathers) + memory scopes
+                                    // covering mama_recall/mama_save. allowed_destinations stays [] - NO new
+                                    // send surface (constraint 2).
+                                    project_refs: [{ kind: 'project', id: projectId }],
+                                    raw_connectors: codeActRawConnectors,
+                                    memory_scopes: resolveCodeActMemoryScopes((0, scope_context_js_1.deriveMemoryScopes)({ source: 'operator', channelId: 'report', projectId }), getAdapter()),
+                                    allowed_destinations: [],
+                                },
+                                tier: 2, // write tier: the report may mama_save (matches code-act write tier)
+                                budget: { wall_seconds: wallSeconds },
+                                expires_at: new Date(Date.now() + wallSeconds * 1000 + 30_000).toISOString(),
+                            });
+                        }
+                        : undefined,
+                    run: async (prompt, envelope) => {
+                        const result = await agentLoop.runWithContent([{ type: 'text', text: prompt }], {
+                            sessionKey: OPERATOR_REPORT_SESSION_KEY,
+                            source: 'operator',
+                            channelId: 'report',
+                            ...(envelope ? { envelope } : {}),
+                        });
+                        return { response: result.response, history: result.history };
+                    },
+                    log: (line) => console.log(line),
+                    fullReportTag: OPERATOR_FULL_REPORT_TAG,
+                }),
+                review: (trigger, context) => reviewTriggerCLI(trigger, context),
+                output: reportOutput,
+                reportScheduler,
+                // M2.3: the scheduled full report self-gathers via the persona agent's gateway tools
+                // (the Kagemusha lesson: a reporter with tools has substance; a window summary alone
+                // reports "quiet" whenever polling is between batches).
+                fullReportSelfGather: [
+                    'kagemusha_overview() for room/task/message counts',
+                    'kagemusha_tasks({}) for the open task board, plus kagemusha_tasks({ status: "review" }) for items awaiting review (status values must be real board statuses like pending/in_progress/review - invented labels match nothing)',
+                    'kagemusha_entities({ activeOnly: true }) for active channels, then kagemusha_messages({ channelId }) on the busiest 2-3 (since defaults to the last 7 days; pass an ISO-8601 timestamp like since: "2026-07-09T00:00:00Z" to narrow it - never a phrase like "24h ago")',
+                    'mama_recall(query) for memory relevant to what you find',
+                ],
+                // Kagemusha dual output: the same scheduled run updates the /ui operator board
+                // slots via report_publish, then writes the plain-text owner report.
+                fullReportBoardLines: buildBoardPublishLines(),
+                config: {
+                    tickMs: Number(process.env.MAMA_TRIGGER_LOOP_TICK_MS || 60_000),
+                    drainLimit: Number(process.env.MAMA_TRIGGER_LOOP_DRAIN_LIMIT || 200),
+                    authorEveryNTicks: Number(process.env.MAMA_TRIGGER_LOOP_AUTHOR_EVERY || 30),
+                    reviewEveryNTicks: Number(process.env.MAMA_TRIGGER_LOOP_REVIEW_EVERY || 240),
+                    authorWindowSize: 50,
+                    reportEveryNTicks: Number(process.env.MAMA_TRIGGER_LOOP_REPORT_EVERY || 15),
+                    nudgeDebounceMs: Number(process.env.MAMA_TRIGGER_LOOP_NUDGE_DEBOUNCE_MS || 15_000),
+                },
+                log: (line) => console.log(line),
+            });
+            if (reportOutput) {
+                console.log('✓ Trigger loop owner-report leg enabled (telegram)');
+            }
+            if (reportScheduler) {
+                console.log(`✓ Trigger loop scheduled full-report leg enabled (local hours: ${fullReportHours.join(', ')})`);
+            }
+            const stopTriggerLoop = triggerLoop.start();
+            // M2.4: point the connector sink's forwarder at this loop now that it exists.
+            triggerLoopNudge.current = () => triggerLoop.nudge();
+            gateways.push({
+                stop: async () => {
+                    triggerLoopNudge.current = null;
+                    stopTriggerLoop();
+                    // Close the operator triggers.db handle (PR #119 review: was leaked on shutdown).
+                    triggerRegistry.close();
+                },
+            });
+            console.log('✓ Trigger loop enabled (MAMA_TRIGGER_LOOP=1, read-only surface mode)');
+        }
+        catch (error) {
+            console.error('[trigger-loop] FAILED to start - daemon continues WITHOUT the trigger loop. Fix and restart:', error);
+        }
+    }
     // ── Phase 10: API Server + Routes ────────────────────────────────────────
     const { apiServer, eventBus } = await (0, api_server_init_js_1.initApiServer)({
         config,
@@ -589,6 +1001,7 @@ async function runAgentLoop(config, options = {}) {
         getAdapter,
         envelopeMetadata: envelopeBootstrap.metadata,
         envelopeAuthority: envelopeBootstrap.envelopeAuthority,
+        contextCompileService,
     });
     await (0, api_routes_init_js_1.registerApiRoutes)({
         config,