@jungjaehoon/mama-os 0.36.1 → 0.37.0

package/dist/cli/commands/start.js

@@ -45,11 +45,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CONDUCTOR_TOOL_POLICY = exports.OPERATOR_REPORT_TOOL_POLICY = exports.WORKORDER_TOOL_POLICIES = void 0;
+exports.OPERATOR_REPORT_TOOL_POLICY = exports.WORKORDER_TOOL_POLICIES = void 0;
 exports.createCorePrincipalRegistry = createCorePrincipalRegistry;
 exports.createCorePrincipalResolver = createCorePrincipalResolver;
 exports.requireRuntimeBackend = requireRuntimeBackend;
-exports.assertConductorBackendSupported = assertConductorBackendSupported;
 exports.serializeCodeActExecutionResult = serializeCodeActExecutionResult;
 exports.deriveCodeActToolPolicy = deriveCodeActToolPolicy;
 exports.resolveCodeActAgentPolicy = resolveCodeActAgentPolicy;
@@ -58,8 +57,6 @@ exports.buildFullReportGatherLines = buildFullReportGatherLines;
 exports.causeEventIdsFromPayload = causeEventIdsFromPayload;
 exports.workOrderEnvelopeScope = workOrderEnvelopeScope;
 exports.temporalTaskBinding = temporalTaskBinding;
-exports.buildConductorAgentPolicy = buildConductorAgentPolicy;
-exports.resolveConductorConfig = resolveConductorConfig;
 exports.buildOperatorReportAgentPolicy = buildOperatorReportAgentPolicy;
 exports.buildWorkOrderAgentPolicy = buildWorkOrderAgentPolicy;
 exports.bindCodeActParentModelRun = bindCodeActParentModelRun;
@@ -77,6 +74,7 @@ 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 read_js_1 = require("../../evidence/read.js");
 const tool_registry_js_1 = require("../../agent/tool-registry.js");
+const prompt_enhancer_js_1 = require("../../agent/prompt-enhancer.js");
 const gateway_tool_catalog_js_1 = require("../../agent/gateway-tool-catalog.js");
 const tool_policy_js_1 = require("../../agent/code-act/tool-policy.js");
 const run_context_registry_js_1 = require("../../agent/code-act/run-context-registry.js");
@@ -125,12 +123,12 @@ const console_brief_js_1 = require("../../operator/console-brief.js");
 const task_ledger_js_1 = require("../../operator/task-ledger.js");
 const board_refresh_gate_js_1 = require("../../operator/board-refresh-gate.js");
 const workorder_publishers_js_1 = require("../../operator/workorder-publishers.js");
-const conductor_inbox_js_1 = require("../../operator/conductor-inbox.js");
-const conductor_session_js_1 = require("../../operator/conductor-session.js");
-const conductor_js_1 = require("../../operator/conductor.js");
-const board_reground_js_1 = require("../../operator/board-reground.js");
+const owner_event_inbox_js_1 = require("../../operator/owner-event-inbox.js");
+const owner_event_effects_js_1 = require("../../operator/owner-event-effects.js");
+const owner_event_loop_js_1 = require("../../operator/owner-event-loop.js");
+const owner_event_prompt_js_1 = require("../../operator/owner-event-prompt.js");
+const owner_event_policy_js_1 = require("../../operator/owner-event-policy.js");
 const leg_cadence_js_1 = require("../../operator/leg-cadence.js");
-const session_pool_js_1 = require("../../agent/session-pool.js");
 const temporal_worker_js_1 = require("../../operator/temporal-worker.js");
 const temporal_runtime_js_1 = require("../../operator/temporal-runtime.js");
 const temporal_init_js_1 = require("../runtime/temporal-init.js");
@@ -161,11 +159,6 @@ function requireRuntimeBackend(value) {
     }
     throw new Error(`Unsupported agent backend: ${String(value)}`);
 }
-function assertConductorBackendSupported(enabled, backend) {
-    if (enabled && backend === 'codex') {
-        throw new Error('conductor.enabled requires the claude or cline backend - codex session lifecycle lands in S2');
-    }
-}
 function serializeCodeActExecutionResult(result, toolCalls, hostToolExecutions = []) {
     const hostToolsInvoked = [
         ...new Set(hostToolExecutions.filter((execution) => execution.success).map((execution) => execution.name)),
@@ -544,87 +537,6 @@ function buildProjectedLanePrompt(innerTools, surface, privateConnectorPolicy) {
         privateConnectorPolicy,
     }).prompt;
 }
-/**
- * The conductor's grant (S1). Reads and judgment surfaces plus the ONE write
- * family the spec's center names: committing work orders and board cards. No
- * sends, no memory writes, no compile - the untrusted-input lane stays the
- * most restricted lane, not the least (review F2/security).
- */
-exports.CONDUCTOR_TOOL_POLICY = {
-    roleName: 'conductor',
-    allowedTools: [
-        'board_read',
-        'changes_read',
-        'mama_recall',
-        'mama_search',
-        'task_create',
-        'task_list',
-        'task_update',
-        'workorder_request',
-        'workorder_status',
-    ],
-};
-/** Mirrors buildOperatorReportAgentPolicy - same shape, conductor grant. */
-function buildConductorAgentPolicy(model, backend, privateConnectorPolicy) {
-    const blockedTools = [];
-    const innerTools = uniqueToolList(exports.CONDUCTOR_TOOL_POLICY.allowedTools);
-    const allowedTools = uniqueToolList([...innerTools]);
-    const agentContext = {
-        source: 'conductor',
-        platform: 'cli',
-        roleName: exports.CONDUCTOR_TOOL_POLICY.roleName,
-        role: {
-            allowedTools,
-            blockedTools,
-            allowedPaths: [],
-            systemControl: false,
-            sensitiveAccess: false,
-            model,
-        },
-        session: {
-            sessionId: 'conductor:main',
-            channelId: 'conductor',
-            startedAt: new Date(),
-        },
-        capabilities: allowedTools,
-        limitations: blockedTools.map((tool) => `Cannot use ${tool}`),
-        // Write tier: board cards and work orders only - matches the envelope.
-        tier: 2,
-        backend,
-    };
-    return {
-        agentContext,
-        gatewayToolsPrompt: (0, gateway_tool_catalog_js_1.buildGatewayToolCatalog)({
-            surface: 'multi-agent-generic',
-            allowedTools: innerTools,
-            privateConnectorPolicy,
-        }).prompt,
-        briefProjectionPolicy: DISABLED_PRIVATE_CONNECTOR_POLICY,
-    };
-}
-/**
- * Merge + validate the conductor config at boot. No-fallback: a malformed
- * value must crash loudly, not silently clamp (review F10: tickMs 0 spins
- * the event loop with a DB write per iteration).
- */
-function resolveConductorConfig(config) {
-    const resolved = {
-        ...types_js_1.DEFAULT_CONFIG.conductor,
-        ...(config.conductor ?? {}),
-    };
-    const positive = [
-        ['tickMs', resolved.tickMs, 1_000],
-        ['maxAgeMs', resolved.maxAgeMs, 60_000],
-        ['maxTurns', resolved.maxTurns, 1],
-        ['maxTokens', resolved.maxTokens, 1_000],
-    ];
-    for (const [name, value, min] of positive) {
-        if (!Number.isFinite(value) || value < min) {
-            throw new Error(`conductor.${name} must be a number >= ${min}, got ${String(value)}`);
-        }
-    }
-    return resolved;
-}
 /**
  * Build the Code-Act role the operator report lane runs under.
  *
@@ -757,7 +669,7 @@ function buildSystemAgentProcessDefaults(config) {
     };
 }
 const OWNER_BOARD_FULL_REPAIR_CHANNEL = 'host:owner-workorder:board-full';
-/** Build the enqueue-and-ack handler shared by direct owner and conductor requests. */
+/** Build the enqueue-and-ack handler shared by owner chat and owner-event turns. */
 function buildOwnerWorkOrderRequestHandler(deps) {
     const now = deps.now ?? Date.now;
     const log = deps.log ?? ((line) => ownerWorkOrderLogger.info(line));
@@ -791,11 +703,20 @@ function buildOwnerWorkOrderRequestHandler(deps) {
                 }
             }
             else if (kind === 'wiki') {
-                idempotencyKey = (0, workorder_publishers_js_1.wikiBatchKey)('manual', requestedAt);
-                payload = { batchId: `${requestedAt}-manual`, events: ['manual'] };
+                if (causeEventIds && causeEventIds.length > 0) {
+                    idempotencyKey = (0, workorder_publishers_js_1.ownerEventWorkOrderKey)('wiki', causeEventIds);
+                    payload = { batchId: idempotencyKey, events: [...causeEventIds] };
+                }
+                else {
+                    idempotencyKey = (0, workorder_publishers_js_1.wikiBatchKey)('manual', requestedAt);
+                    payload = { batchId: `${requestedAt}-manual`, events: ['manual'] };
+                }
             }
             else {
-                idempotencyKey = (0, workorder_publishers_js_1.promotionManualKey)(requestedAt);
+                idempotencyKey =
+                    causeEventIds && causeEventIds.length > 0
+                        ? (0, workorder_publishers_js_1.ownerEventWorkOrderKey)('memory-curation', causeEventIds)
+                        : (0, workorder_publishers_js_1.promotionManualKey)(requestedAt);
                 payload = { scheduledAt: new Date(requestedAt).toISOString() };
             }
             (0, workorder_publishers_js_1.validateWorkOrderPayload)(kind, payload);
@@ -1359,12 +1280,6 @@ async function runAgentLoop(config, options = {}) {
     // and point it at the loop once it exists. Null until then -> nudge no-ops (no loop = nothing to
     // wake), which remains safe while the trigger loop is still booting or explicitly disabled.
     const triggerLoopNudge = { current: null };
-    // M8: board-reconcile feed. The trigger loop is built BEFORE the event bus
-    // exists (initApiServer), so it emits through this mutable sink (same
-    // pattern as triggerLoopNudge above).
-    const channelDeltaSink = {
-        current: null,
-    };
     // Operator DB + native task ledger (M8): wired UNCONDITIONALLY -- the task
     // tools are standard gateway tools and must work even when the trigger loop
     // is off (review finding on #142). Single handle, closed once at shutdown.
@@ -1384,11 +1299,12 @@ async function runAgentLoop(config, options = {}) {
     // One host-owned gate spans owner workorder requests, route scheduling,
     // delta ingestion, and completion verification for this boot.
     const boardRefreshGate = process.env.MAMA_BOARD_RECONCILE === '1' ? new board_refresh_gate_js_1.BoardRefreshGate() : null;
-    // S1: durable conductor inbox - constructed UNCONDITIONALLY so drained
-    // batches persist before the cursor commits even while the conductor is
-    // disabled (that accumulation IS the shadow-mode data; retention inside
-    // ConductorInbox keeps it bounded).
-    const conductorInbox = new conductor_inbox_js_1.ConductorInbox(operatorDb);
+    // Durable MAMA owner-event journal. It uses new tables rather than replaying
+    // the legacy default-off Conductor shadow backlog on cutover.
+    const ownerEventInbox = new owner_event_inbox_js_1.OwnerEventInbox(operatorDb);
+    const ownerEventEffectLedger = new owner_event_effects_js_1.OwnerEventEffectLedger(operatorDb);
+    toolExecutor.setOwnerEventEffectLedger(ownerEventEffectLedger);
+    let stopOwnerEventRuntime = null;
     // S2: leg cadence watchdog - its OWN timer, deliberately outside the
     // trigger loop (a watchdog inside the thing it watches dies with it).
     // Legs declare+beat at their own tick sites via the singleton; pages ride
@@ -1423,14 +1339,6 @@ async function runAgentLoop(config, options = {}) {
             console.error('[leg-watchdog] check failed:', err);
         }
     }, 60_000);
-    const conductorConfig = resolveConductorConfig(config);
-    try {
-        assertConductorBackendSupported(conductorConfig.enabled, runtimeBackend);
-    }
-    catch (error) {
-        operatorDb.close();
-        throw error;
-    }
     // ── Stage-2 workorder consumer (plan S2-T3): the only system run path.
     // Constructed before production runtime assembly registers per-kind
     // completion hooks, and started only after route registration and recovery
@@ -1446,16 +1354,20 @@ async function runAgentLoop(config, options = {}) {
     gateways.push({
         stop: async () => {
             clearInterval(legWatchdog);
-            // Consumer stop BEFORE db close (same gateway = ordered; parallel
-            // gateways would race an in-flight tick into "database is not open").
-            await (0, temporal_runtime_js_1.closeTemporalRuntimeBeforeDatabase)(temporalRuntime, workOrderConsumer, () => {
+            // All users of the shared operator DB stop inside this one gateway.
+            // Shutdown invokes gateways in parallel, so a separate owner-event
+            // gateway would race its final ACK against this close.
+            await (0, owner_event_loop_js_1.closeOwnerEventBeforeDatabase)(async () => {
+                await stopOwnerEventRuntime?.();
+                stopOwnerEventRuntime = null;
+            }, () => (0, temporal_runtime_js_1.closeTemporalRuntimeBeforeDatabase)(temporalRuntime, workOrderConsumer, () => {
                 try {
                     operatorDb.close();
                 }
                 catch {
                     /* already closed */
                 }
-            }).catch(() => { });
+            })).catch(() => { });
         },
     });
     {
@@ -1637,12 +1549,6 @@ async function runAgentLoop(config, options = {}) {
     // MAMA_TRIGGER_LOOP=0 is the explicit opt-out. Placed after initConnectors (which feeds
     // connector_event_index) and after mama-core initDB. Read-only: recall/surface/log.
     const { isOperatorTriggerLoopEnabled, resolveOperatorReportChatId } = await import('../../operator/runtime-config.js');
-    if (!isOperatorTriggerLoopEnabled(process.env) && conductorConfig.enabled) {
-        // The conductor lives inside the trigger-loop branch (its inbox is fed by
-        // the loop's drain). enabled=true with the loop off would otherwise boot
-        // silently into a conductor that never runs (review).
-        console.error('[conductor] conductor.enabled=true but the trigger loop is disabled - the conductor will NOT run. Enable the trigger loop or disable the conductor.');
-    }
     if (isOperatorTriggerLoopEnabled(process.env)) {
         let stopTriggerAgentRuntime;
         // Component isolation (PR #119 review): a trigger-loop bootstrap failure (bad import,
@@ -1725,13 +1631,17 @@ async function runAgentLoop(config, options = {}) {
                 dataDir: config.agent.cline_data_dir,
             });
             stopTriggerAgentRuntime = () => triggerAgentRuntime.stop();
+            const ownerEventEnvelopeAuthority = envelopeBootstrap.envelopeAuthority;
+            const ownerEventExecution = (0, owner_event_policy_js_1.resolveOwnerEventExecution)({
+                issuance: envelopeBootstrap.metadata.issuance,
+                hasAuthority: ownerEventEnvelopeAuthority !== undefined,
+            });
             const triggerLoop = new OperatorTriggerLoop({
                 backend: runtimeBackend,
                 delta: new ConnectorDeltaRepo(getAdapter(), (0, config_manager_js_1.expandPath)('~/.mama/operator/trigger-loop-cursors.json')),
                 memory: createMamaMemoryPort(),
                 registry: triggerRegistry,
-                conductorInbox,
-                onChannelDelta: (channelKey, lines, eventIds) => channelDeltaSink.current?.(channelKey, lines, eventIds),
+                ...(ownerEventExecution.enabled ? { ownerEventInbox } : {}),
                 askAgent: triggerAgentRuntime.askAuthor,
                 // 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.
@@ -1872,97 +1782,125 @@ async function runAgentLoop(config, options = {}) {
                 (0, leg_cadence_js_1.getLegCadence)()?.declare('full-report', 26 * 60 * 60 * 1000);
             }
             const stopTriggerLoop = triggerLoop.start();
+            stopOwnerEventRuntime = async () => {
+                await Promise.all([stopTriggerLoop(), triggerAgentRuntime.stop()]);
+            };
             // M2.4: point the connector sink's forwarder at this loop now that it exists.
             triggerLoopNudge.current = () => triggerLoop.nudge();
             // S1-T3: owner-intent forwarder - report_request routes to the SAME
             // report machinery (fresh session, delta anchor, consume semantics).
             toolExecutor.setReportRequestHandler(() => triggerLoop.startFullReport());
-            // S1: the stateful conductor consumes the durable inbox on its own
-            // session:conductor:main lane. Default-off; the inbox records
-            // either way (shadow-mode data).
-            let conductorTimer = null;
-            let conductorTickPromise = null;
-            if (conductorConfig.enabled) {
-                const conductorSession = new conductor_session_js_1.ConductorSession((0, session_pool_js_1.getSessionPool)(), {
-                    maxAgeMs: conductorConfig.maxAgeMs,
-                    maxTurns: conductorConfig.maxTurns,
-                    maxTokens: conductorConfig.maxTokens,
+            if (ownerEventExecution.enabled && ownerEventEnvelopeAuthority) {
+                // MAMA itself owns connector events. This is the same AgentLoop and
+                // owner operating policy as the owner console, on a durable per-channel
+                // background session. There is no separate Conductor persona.
+                const ownerRole = config.roles?.definitions.owner_console ?? types_js_1.DEFAULT_ROLES.definitions.owner_console;
+                const ownerEventContext = (0, owner_event_policy_js_1.buildOwnerEventAgentContext)({
+                    backend: runtimeBackend,
+                    model: config.agent.model,
+                    ownerRole,
+                    privateConnectorPolicy,
                 });
-                const conductorPolicy = buildConductorAgentPolicy(config.agent.model, runtimeBackend, privateConnectorPolicy);
-                // Per-run envelope, mirroring the report lane: without it every
-                // model_tool call dies 'envelope_missing' while the run resolves and
-                // acks the batch - zero work, green ledger (review F2).
-                const conductorIssueEnvelope = envelopeBootstrap.envelopeAuthority && envelopeBootstrap.metadata.issuance !== 'off'
-                    ? async () => {
-                        const projectId = (0, reactive_config_js_1.resolveReactiveProjectRoot)(config, process.env);
-                        const wallSeconds = 300; // one judgment turn, not a gather run
-                        return envelopeBootstrap.envelopeAuthority.buildAndPersist({
-                            agent_id: 'conductor',
-                            instance_id: (0, node_crypto_1.randomUUID)(),
-                            source: 'watch',
-                            channel_id: 'conductor',
-                            trigger_context: { user_text: '<conductor batch judgment>' },
-                            scope: {
-                                project_refs: [{ kind: 'project', id: projectId }],
-                                // The conductor reads channel text from its own durable
-                                // inbox, never from connectors - no raw read authority.
-                                raw_connectors: [],
-                                memory_scopes: uniqueMemoryScopes((0, scope_context_js_1.deriveMemoryScopes)({
-                                    source: 'conductor',
-                                    channelId: 'conductor',
-                                    projectId,
-                                })),
-                                allowed_destinations: [], // NO send surface
-                            },
-                            tier: 2,
-                            budget: { wall_seconds: wallSeconds },
-                            expires_at: new Date(Date.now() + wallSeconds * 1000 + 30_000).toISOString(),
-                        });
-                    }
-                    : undefined;
-                const conductor = new conductor_js_1.Conductor({
-                    inbox: conductorInbox,
-                    session: conductorSession,
+                const ownerEventPromptEnhancer = new prompt_enhancer_js_1.PromptEnhancer();
+                const ownerEventIssueEnvelope = async (batch) => {
+                    const projectId = (0, reactive_config_js_1.resolveReactiveProjectRoot)(config, process.env);
+                    const wallSeconds = 300;
+                    return ownerEventEnvelopeAuthority.buildAndPersist({
+                        agent_id: 'mama-owner',
+                        instance_id: (0, node_crypto_1.randomUUID)(),
+                        source: 'watch',
+                        channel_id: batch.channelKey,
+                        trigger_context: { user_text: '<MAMA owner event turn>' },
+                        scope: {
+                            project_refs: [{ kind: 'project', id: projectId }],
+                            raw_connectors: [
+                                ...privateConnectorPolicy.projectRawConnectors('owner_console', codeActRawConnectors),
+                            ],
+                            memory_scopes: uniqueMemoryScopes((0, scope_context_js_1.deriveMemoryScopes)({
+                                source: 'owner-event',
+                                channelId: batch.channelKey,
+                                projectId,
+                            })),
+                            allowed_destinations: reportChatId
+                                ? [{ kind: 'telegram', id: reportChatId }]
+                                : [],
+                        },
+                        tier: 1,
+                        budget: { wall_seconds: wallSeconds },
+                        expires_at: new Date(Date.now() + wallSeconds * 1000 + 30_000).toISOString(),
+                    });
+                };
+                const ownerEventLoop = new owner_event_loop_js_1.OwnerEventLoop({
+                    inbox: ownerEventInbox,
                     runner: agentLoop,
-                    reground: () => (0, board_reground_js_1.buildBoardReground)(taskLedger),
-                    agentContext: conductorPolicy.agentContext,
-                    issueEnvelope: conductorIssueEnvelope,
+                    agentContext: ownerEventContext,
+                    buildPrompt: async (batch) => (0, owner_event_prompt_js_1.buildOwnerEventPrompt)({
+                        batch,
+                        ownerBrief: (0, console_brief_js_1.projectConsoleBriefForPrompt)((0, console_brief_js_1.loadConsoleBrief)(), privateConnectorPolicy),
+                        skillContent: await ownerEventPromptEnhancer.detectSkillMatch(batch.lines.join('\n')),
+                        ownerTelegramChatId: reportChatId,
+                    }),
+                    issueEnvelope: ownerEventIssueEnvelope,
+                    getNoUpdateMaxId: (scope) => taskLedger.maxNoUpdateId(scope),
+                    getTerminalReceipt: (batch) => {
+                        const confirmedEffects = ownerEventEffectLedger.confirmedKinds(batch.id);
+                        if (confirmedEffects.length > 0) {
+                            return { status: 'acted', tools: confirmedEffects };
+                        }
+                        const acceptedWorkOrder = taskLedger.findWorkOrderByOccurrence('board', (0, workorder_publishers_js_1.boardBatchKey)(batch.eventIds)) ??
+                            taskLedger.findWorkOrderByOccurrence('wiki', (0, workorder_publishers_js_1.ownerEventWorkOrderKey)('wiki', batch.eventIds)) ??
+                            taskLedger.findWorkOrderByOccurrence('memory-curation', (0, workorder_publishers_js_1.ownerEventWorkOrderKey)('memory-curation', batch.eventIds));
+                        if (acceptedWorkOrder) {
+                            return { status: 'delegated', tools: ['workorder_request'] };
+                        }
+                        if (taskLedger.maxNoUpdateId(`owner-event:${batch.id}`) > 0) {
+                            return { status: 'no_update', tools: [] };
+                        }
+                        return null;
+                    },
+                    recordTriggerOutcome: (triggerId, outcome) => triggerRegistry.recordOutcome(triggerId, outcome),
+                    onDead: async (message) => {
+                        console.error(message);
+                        await (0, leg_cadence_js_1.getLegPageNotifier)()?.(message);
+                    },
                     log: (line) => console.log(line),
                 });
-                conductorTimer = setInterval(() => {
-                    if (conductorTickPromise)
-                        return; // never overlap ticks
-                    conductorTickPromise = conductor
+                let ownerEventTickPromise = null;
+                const runOwnerEventTick = () => {
+                    if (ownerEventTickPromise)
+                        return;
+                    ownerEventTickPromise = ownerEventLoop
                         .tick()
-                        .catch((err) => console.error(`[conductor] tick failed: ${err instanceof Error ? err.message : String(err)}`))
+                        .catch((err) => console.error(`[owner-event] tick failed: ${err instanceof Error ? err.message : String(err)}`))
                         .finally(() => {
-                        conductorTickPromise = null;
+                        ownerEventTickPromise = null;
                     });
-                }, conductorConfig.tickMs);
-                console.log(`✓ Conductor enabled (tick ${conductorConfig.tickMs}ms)`);
+                };
+                const ownerEventTimer = setInterval(runOwnerEventTick, 5_000);
+                ownerEventTimer.unref?.();
+                runOwnerEventTick();
+                console.log('✓ MAMA owner-event agent enabled');
+                stopOwnerEventRuntime = async () => {
+                    triggerLoopNudge.current = null;
+                    clearInterval(ownerEventTimer);
+                    // Let an in-flight effect reach its durable ACK before the shared
+                    // operator DB closes.
+                    if (ownerEventTickPromise)
+                        await ownerEventTickPromise;
+                    await Promise.all([stopTriggerLoop(), triggerAgentRuntime.stop()]);
+                };
             }
             else {
-                console.log('Conductor inbox recording (conductor disabled)');
+                const reason = ownerEventExecution.enabled
+                    ? 'owner-event envelope authority unavailable'
+                    : ownerEventExecution.reason;
+                console.error(`[owner-event] disabled: ${reason}`);
             }
-            gateways.push({
-                stop: async () => {
-                    triggerLoopNudge.current = null;
-                    if (conductorTimer)
-                        clearInterval(conductorTimer);
-                    // Let an in-flight tick finish BEFORE the operator DB closes: a
-                    // SIGTERM mid-ack otherwise throws on a closed handle, the row
-                    // stays 'claimed', and every launchd restart replays the batch
-                    // (review F7).
-                    if (conductorTickPromise)
-                        await conductorTickPromise;
-                    await Promise.all([stopTriggerLoop(), triggerAgentRuntime.stop()]);
-                    // The shared operator DB handle is closed by the unconditional stop
-                    // hook above (single owner); nothing to close here.
-                },
-            });
-            temporalLogger.info('Trigger loop enabled (default-on, read-only surface mode)');
+            temporalLogger.info('Trigger loop enabled (MAMA owner-event intake + report mode)');
         }
         catch (error) {
+            await stopOwnerEventRuntime?.().catch(() => { });
+            stopOwnerEventRuntime = null;
             await stopTriggerAgentRuntime?.().catch(() => { });
             console.error('[trigger-loop] FAILED to start - daemon continues WITHOUT the trigger loop. Fix and restart:', error);
         }
@@ -1984,7 +1922,6 @@ async function runAgentLoop(config, options = {}) {
         connectorConfigLoadResult,
         privateConnectorPolicy,
     });
-    channelDeltaSink.current = (channelKey, lines, eventIds) => eventBus.emit({ type: 'operator:channel-delta', channelKey, lines, eventIds });
     const apiRoutesHandle = await (0, api_routes_init_js_1.registerApiRoutes)({
         config,
         apiServer,