@jungjaehoon/mama-os 0.48.4 → 0.49.1

package/dist/gateways/message-router.js

@@ -50,6 +50,7 @@ exports.causeFromOwnerMessage = causeFromOwnerMessage;
 exports.protectImageAnalysis = protectImageAnalysis;
 exports.buildUploadedMediaInstructions = buildUploadedMediaInstructions;
 exports.hashSessionPolicyFingerprint = hashSessionPolicyFingerprint;
+exports.projectOwnerConversationAgency = projectOwnerConversationAgency;
 exports.agentSavedInTurn = agentSavedInTurn;
 exports.createMockAgentLoop = createMockAgentLoop;
 const node_path_1 = require("node:path");
@@ -61,6 +62,7 @@ const member_effective_scope_js_1 = require("./member-effective-scope.js");
 const session_pool_js_1 = require("../agent/session-pool.js");
 const agent_loop_js_1 = require("../agent/agent-loop.js");
 const console_brief_js_1 = require("../operator/console-brief.js");
+const owner_runtime_js_1 = require("../operator/owner-runtime.js");
 const role_manager_js_1 = require("../agent/role-manager.js");
 const gateway_tool_catalog_js_1 = require("../agent/gateway-tool-catalog.js");
 const private_prompt_overlay_js_1 = require("../connectors/private-prompt-overlay.js");
@@ -68,7 +70,6 @@ const context_prompt_builder_js_1 = require("../agent/context-prompt-builder.js"
 const prompt_enhancer_js_1 = require("../agent/prompt-enhancer.js");
 const principal_js_1 = require("./principal.js");
 const debugLogger = __importStar(require("@jungjaehoon/mama-core/debug-logger"));
-const audit_task_queue_js_1 = require("../memory/audit-task-queue.js");
 const agent_notice_queue_js_1 = require("../memory/agent-notice-queue.js");
 const scope_context_js_1 = require("../memory/scope-context.js");
 const learning_context_js_1 = require("../operator/learning-context.js");
@@ -76,7 +77,6 @@ const learning_read_js_1 = require("../operator/learning-read.js");
 const turn_observer_js_1 = require("../operator/turn-observer.js");
 const learning_markers_js_1 = require("../operator/learning-markers.js");
 const recall_bundle_formatter_js_1 = require("../memory/recall-bundle-formatter.js");
-const save_candidate_extractor_js_1 = require("../memory/save-candidate-extractor.js");
 const untrusted_content_js_1 = require("../utils/untrusted-content.js");
 const security_monitor_js_1 = require("../security/security-monitor.js");
 const agent_store_js_1 = require("../db/agent-store.js");
@@ -221,12 +221,19 @@ const OWNER_CONSOLE_OPERATING_DISCIPLINE = `## Owner console operating disciplin
 - You are the owner's operator, not an advisor. Report what you found and what you did; do not hand back work you could have done yourself.
 - Gather before answering. Any question about status, work, or what happened is answered by CALLING your gateway tools first. Never reply "please check X" when a gateway tool can check X - check it, then report.
 - Never claim a check you did not run. If a tool errored or was denied, name the tool and the error; a missing answer is reported as missing, never smoothed over.
-- Act by default; ask only before the irreversible. Reversible work is yours to do and then report: reading, analysing, ranking, drafting, and writes whose only audience is this console (mama_save, task_create/task_update on your task board, report_request). Ask first only when the effect leaves this conversation and cannot be taken back - sending to another channel (telegram_send), uploading or overwriting shared files (drive_upload), storing credentials, or delegating a run you cannot cancel.
+- Act by default; ask only before the irreversible. Reversible work is yours to do and then report: reading, analysing, ranking, drafting, and writes whose only audience is this console (mama_save, task_create/task_update on your task board). Ask first only when the effect leaves this conversation and cannot be taken back - sending to another channel (telegram_send), uploading or overwriting shared files (drive_upload), storing credentials, or delegating a run you cannot cancel.
+- A status or full-report request is YOUR judgment task in THIS conversation. Use compact descriptors and overview reads first, deepen only the material uncertainties through bounded pages, take authorized reversible actions, and answer the owner directly. Never hand it to another report agent and never reply with only an acknowledgement.
 - Do not close by offering work you could have done. "Shall I rank these?" or "want it broken down by person?" is work, not a question - if you can do it now it belongs in this reply. End with what you did and what the OWNER has to decide, never with a menu of things you are willing to do next.
 - Multi-step requests: decide the steps, carry out the reversible ones, then report the outcome. Do not return the plan as a suggestion and stop.
 - Synthesize, do not dump. A raw tool result is evidence, not an answer - say what it means for the owner and cite which source answered.
 - Before saying something is done, verify it (re-read the artifact or re-run the query) and say what you verified.
 - Reply in the language the owner writes in.`;
+function projectOwnerConversationAgency(roleName, role) {
+    if (roleName !== 'owner_console') {
+        return role;
+    }
+    return (0, owner_runtime_js_1.projectOwnerRuntimeRole)(role);
+}
 /** Channel-less host alarms (workorder failures) park here; every resumed
  *  owner turn reads this key in addition to its own channel key. */
 exports.OPERATOR_BROADCAST_NOTICE_KEY = 'operator:broadcast';
@@ -268,7 +275,7 @@ const MEMBER_BLOCKED_TOOLS = [
     'Read',
     'Write',
     'Bash',
-    'delegate',
+    'native_subagent',
     'discord_send',
     'slack_send',
     'telegram_send',
@@ -276,7 +283,6 @@ const MEMBER_BLOCKED_TOOLS = [
     'task_create',
     'task_update',
     'task_reclassify',
-    'report_request',
     'report_publish',
     'wiki_read',
     'wiki_publish',
@@ -358,9 +364,6 @@ function sanitizeForPrompt(text) {
         .replace(/</g, '&lt;')
         .replace(/>/g, '&gt;');
 }
-function stripGatewayDecorations(text) {
-    return text.replace(/^(?:\s*\|\|[\s\S]*?\|\|\s*)+/u, '').trim();
-}
 /**
  * True when the agent persisted memory during THIS turn (gateway mama_save in
  * the reasoning header) - the extractor safety net then skips to avoid the
@@ -406,28 +409,11 @@ class MessageRouter {
     envelopeConfig;
     envelopeAuthority;
     privateConnectorPolicy;
-    reportCarry;
-    ownerReportInbox;
     memberScopeResolver;
     roleManager;
     promptEnhancer;
-    gatewayRegistry = null;
-    memoryAgentProcessManager;
-    memoryAuditQueue;
     memoryNoticeQueue = new agent_notice_queue_js_1.AgentNoticeQueue();
-    memoryAuditCooldowns = new Map();
     channelTails = new Map();
-    memoryAgentStats = {
-        turnsObserved: 0,
-        candidatesDetected: 0,
-        factsExtracted: 0,
-        factsSaved: 0,
-        acksApplied: 0,
-        acksSkipped: 0,
-        acksFailed: 0,
-        lastExtraction: null,
-        recentExtractions: [],
-    };
     // Sessions DB for MAMA frontdoor activity logging
     sessionsDb = null;
     setSessionsDb(db) {
@@ -438,11 +424,7 @@ class MessageRouter {
     setUICommandQueue(queue) {
         this.uiCommandQueue = queue;
     }
-    // Validation service for memory agent + MAMA sessions
-    validationService = null;
-    setValidationService(svc) {
-        this.validationService = svc;
-    }
+    setValidationService(_svc) { }
     getPageContextPrefix(message) {
         if (!this.uiCommandQueue) {
             return '';
@@ -518,30 +500,19 @@ class MessageRouter {
         lines.push('</viewer-context>');
         return lines.join('\n') + '\n';
     }
-    setGatewayRegistry(registry) {
-        this.gatewayRegistry = registry;
-    }
-    setMemoryAgent(processManager) {
-        this.memoryAgentProcessManager = processManager;
-        this.memoryAuditQueue = new audit_task_queue_js_1.AuditTaskQueue(async (job) => {
-            const process = await processManager.getSharedProcess('memory');
-            const result = await process.sendMessage(this.buildMemoryAuditPrompt(job), {
-                sourceTurnId: job.turnId,
-                sourceMessageRef: [job.source, job.channelId, job.turnId].filter(Boolean).join(':'),
-                parentModelRunId: job.parentModelRunId,
-            });
-            if (result &&
-                typeof result === 'object' &&
-                'ack' in result &&
-                result.ack &&
-                typeof result.ack === 'object') {
-                return result.ack;
-            }
-            return this.classifyMemoryAuditResponse(typeof result?.response === 'string' ? result.response : '');
-        });
-    }
+    setGatewayRegistry(_registry) { }
     getMemoryAgentStats() {
-        return { ...this.memoryAgentStats };
+        return {
+            turnsObserved: 0,
+            candidatesDetected: 0,
+            factsExtracted: 0,
+            factsSaved: 0,
+            acksApplied: 0,
+            acksSkipped: 0,
+            acksFailed: 0,
+            lastExtraction: null,
+            recentExtractions: [],
+        };
     }
     /**
      * Host-code enqueue into the owner notice surface (Stage-2 workorder
@@ -561,39 +532,6 @@ class MessageRouter {
             relevant_memories: [],
         });
     }
-    /**
-     * Public API for auditing a conversation via the memory agent.
-     * Used by the /api/mama/audit-conversation endpoint for benchmarking.
-     * Bypasses cooldown and candidate detection — caller provides conversation + optional candidates.
-     */
-    async auditConversation(job) {
-        if (!this.memoryAuditQueue) {
-            throw new Error('Memory agent not initialized — cannot audit conversation');
-        }
-        const auditJob = {
-            turnId: `audit_${Date.now()}`,
-            channelKey: 'api:default',
-            source: 'api',
-            scopeContext: job.scopes.map((s) => ({
-                kind: s.kind,
-                id: s.id,
-            })),
-            conversation: job.conversation,
-            candidates: job.candidates?.map((c) => ({
-                id: `api_${Date.now()}`,
-                kind: c.kind,
-                topicHint: c.topicHint,
-                confidence: c.confidence,
-                summary: c.summary,
-                evidence: [c.summary],
-                channelKey: 'api:default',
-                source: 'api',
-                channelId: 'default',
-                createdAt: Date.now(),
-            })),
-        };
-        return this.memoryAuditQueue.enqueue(auditJob);
-    }
     constructor(sessionStore, agentLoop, mamaApi, config = {}, envelopeConfig, envelopeAuthority, dependencies = {}) {
         this.sessionStore = sessionStore;
         this.agentLoop = agentLoop;
@@ -605,8 +543,6 @@ class MessageRouter {
         this.envelopeAuthority = envelopeAuthority;
         this.privateConnectorPolicy =
             dependencies.privateConnectorPolicy ?? DEFAULT_PRIVATE_CONNECTOR_POLICY;
-        this.reportCarry = dependencies.reportCarry;
-        this.ownerReportInbox = dependencies.ownerReportInbox;
         this.memberScopeResolver = dependencies.memberScopeResolver;
         if (this.envelopeConfig && !this.envelopeAuthority) {
             throw new Error('[envelope] ReactiveEnvelopeConfig provided without EnvelopeAuthority');
@@ -647,19 +583,16 @@ class MessageRouter {
     createAgentContext(message, sessionId) {
         // Per-message trust context: chatType is runtime state (a locked allowlist
         // alone cannot prove owner - allowlisted groups contain third parties).
-        const { roleName, role } = this.roleManager.getRoleForSource(message.source, {
-            channelId: message.channelId,
-            chatType: typeof message.metadata?.chatType === 'string' ? message.metadata.chatType : undefined,
-            principal: message.principal,
-        });
+        const { roleName, role } = this.resolveMessageRole(message);
         const surface = roleName === 'owner_console'
             ? 'owner_console'
             : roleName === 'os_agent'
                 ? 'os_agent'
                 : 'multi-agent-generic';
-        const projectedRole = message.principal?.class === 'member'
+        const connectorProjectedRole = message.principal?.class === 'member'
             ? memberReadOnlyRole(role)
             : this.privateConnectorPolicy.projectRole(surface, role);
+        const projectedRole = projectOwnerConversationAgency(roleName, connectorProjectedRole);
         const capabilities = this.roleManager.getCapabilities(projectedRole);
         const limitations = this.roleManager.getLimitations(projectedRole);
         const ctx = (0, context_prompt_builder_js_1.createAgentContext)(message.source, roleName, projectedRole, {
@@ -677,6 +610,13 @@ class MessageRouter {
         }
         return ctx;
     }
+    resolveMessageRole(message) {
+        return this.roleManager.getRoleForSource(message.source, {
+            channelId: message.channelId,
+            chatType: typeof message.metadata?.chatType === 'string' ? message.metadata.chatType : undefined,
+            principal: message.principal,
+        });
+    }
     /**
      * Check if message should trigger auto-translation
      * Returns true for short messages or image-related text
@@ -766,14 +706,17 @@ class MessageRouter {
             });
             assertUsableMemberEffectiveScope(memberEffectiveScope, admittedPrincipal.principalId ?? '');
         }
-        const channelKey = (0, session_pool_js_1.buildChannelKey)(admittedMessage.source, (0, principal_js_1.laneChannelId)(admittedMessage.channelId, lane));
-        const previous = this.channelTails.get(channelKey);
+        const admissionRoleName = this.resolveMessageRole(admittedMessage).roleName;
+        const admissionKey = admissionRoleName === 'owner_console'
+            ? owner_runtime_js_1.OWNER_RUNTIME_SESSION_KEY
+            : (0, session_pool_js_1.buildChannelKey)(admittedMessage.source, (0, principal_js_1.laneChannelId)(admittedMessage.channelId, lane));
+        const previous = this.channelTails.get(admissionKey);
         let release;
         const gate = new Promise((resolve) => {
             release = resolve;
         });
         const currentTail = (previous ?? Promise.resolve()).catch(() => { }).then(() => gate);
-        this.channelTails.set(channelKey, currentTail);
+        this.channelTails.set(admissionKey, currentTail);
         try {
             if (previous) {
                 processOptions?.onQueued?.();
@@ -786,8 +729,8 @@ class MessageRouter {
         }
         finally {
             release();
-            if (this.channelTails.get(channelKey) === currentTail) {
-                this.channelTails.delete(channelKey);
+            if (this.channelTails.get(admissionKey) === currentTail) {
+                this.channelTails.delete(admissionKey);
             }
         }
     }
@@ -853,10 +796,27 @@ This protects your credentials from being exposed in chat logs.`;
         }
         // 1. Get or create session (by source + channelId)
         const session = this.sessionStore.getOrCreate(message.source, sessionChannelId, message.userId, message.channelName);
+        const agentContext = this.createAgentContext(message, session.id);
+        const ownerRuntimeRole = agentContext.roleName === 'owner_console'
+            ? projectOwnerConversationAgency('owner_console', this.resolveMessageRole(message).role)
+            : agentContext.role;
         // 2. Check if session is busy (another request in progress)
         const channelKey = (0, session_pool_js_1.buildChannelKey)(message.source, sessionChannelId);
+        const runtimeSessionKey = agentContext.roleName === 'owner_console' ? owner_runtime_js_1.OWNER_RUNTIME_SESSION_KEY : channelKey;
         const sessionPool = (0, session_pool_js_1.getSessionPool)();
-        const initialSession = sessionPool.getSession(channelKey);
+        const runtimeOwnsSession = runtimeSessionKey === owner_runtime_js_1.OWNER_RUNTIME_SESSION_KEY && this.agentLoop.managesOwnerQueue === true;
+        const ownerSession = runtimeOwnsSession
+            ? sessionPool.peekSession(runtimeSessionKey)
+            : undefined;
+        const initialSession = runtimeOwnsSession
+            ? {
+                sessionId: ownerSession?.sessionId ?? session.id,
+                isNew: !ownerSession?.sessionId,
+                busy: false,
+            }
+            : sessionPool.getSession(runtimeSessionKey);
+        if (ownerSession?.busy)
+            processOptions?.onQueued?.();
         let cliSessionId = initialSession.sessionId;
         let isNewCliSession = initialSession.isNew;
         const busy = initialSession.busy;
@@ -864,12 +824,13 @@ This protects your credentials from being exposed in chat logs.`;
         // assignment sits inside the agent-run block and is not visible at the return.
         let completedModelRunId = null;
         let completedProvenanceReason = 'backend_no_run';
+        let completedOwnerJournalProvenance;
         const sourceTurnId = message.metadata?.messageId ?? `generated:${(0, node_crypto_1.randomUUID)().replace(/-/g, '')}`;
         const sourceMessageRef = [message.source, message.channelId, sourceTurnId]
             .filter(Boolean)
             .join(':');
         // Track lock ownership for proper cleanup in finally block
-        let acquiredLock = !busy; // If not busy, we acquired lock from initialSession
+        let acquiredLock = !runtimeOwnsSession && !busy;
         // If session is busy, notify caller immediately and wait for it to be released
         if (busy) {
             logger.debug(`Session busy for ${channelKey}, notifying client`);
@@ -882,7 +843,7 @@ This protects your credentials from being exposed in chat logs.`;
             while (Date.now() - waitStart < maxWaitMs) {
                 await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
                 // Use read-only peek to avoid side effects (no lock increment)
-                const check = sessionPool.peekSession(channelKey);
+                const check = sessionPool.peekSession(runtimeSessionKey);
                 if (!check.busy) {
                     logger.debug(`Session released for ${channelKey} after ${Math.round((Date.now() - waitStart) / 1000)}s`);
                     break;
@@ -894,7 +855,7 @@ This protects your credentials from being exposed in chat logs.`;
                 }
             }
             // Re-acquire session after wait (properly locks it this time)
-            const reacquired = sessionPool.getSession(channelKey);
+            const reacquired = sessionPool.getSession(runtimeSessionKey);
             if (reacquired.busy) {
                 // Still busy after timeout - we never acquired the lock
                 throw new Error(`Session for ${channelKey} timed out after ${maxWaitMs / 1000}s`);
@@ -907,35 +868,17 @@ This protects your credentials from being exposed in chat logs.`;
         const releaseCliSessionLock = () => {
             if (!acquiredLock || lockReleased)
                 return;
-            sessionPool.releaseSession(channelKey, cliSessionId);
+            sessionPool.releaseSession(runtimeSessionKey, cliSessionId);
             lockReleased = true;
         };
         try {
-            const agentContext = this.createAgentContext(message, session.id);
-            const reportCarryTarget = agentContext.roleName === 'owner_console' && message.source === 'telegram'
-                ? { source: message.source, channelId: message.channelId }
-                : null;
-            const reportCarryChannelKey = reportCarryTarget
-                ? (0, session_pool_js_1.buildChannelKey)(reportCarryTarget.source, (0, principal_js_1.laneChannelId)(reportCarryTarget.channelId, lane))
-                : null;
-            const reportCarryPeek = reportCarryTarget
-                ? (this.reportCarry?.peek(reportCarryTarget) ?? null)
-                : null;
-            // TG-05: inbox lookup only AFTER the owner-console trust check
-            // (reportCarryTarget is non-null only for a verified owner turn). The
-            // snapshot is captured once; its exact ordered IDs are the only
-            // consumable set for this turn.
-            const ownerReportSnapshot = reportCarryTarget
-                ? (this.ownerReportInbox?.snapshot(reportCarryTarget) ?? null)
-                : null;
             const mediaInstructions = buildUploadedMediaInstructions(message, agentContext.role.allowedTools, agentContext.roleName === 'owner_console');
-            // Save user message immediately for crash/refresh resilience. A
-            // report-consuming turn is provisional until its atomic final commit.
+            // Save user message immediately for crash/refresh resilience.
             this.sessionStore.appendMessage(session.id, {
                 role: 'user',
                 content: [message.text, mediaInstructions].filter(Boolean).join('\n\n'),
                 timestamp: Date.now(),
-            }, ownerReportSnapshot ? { sourceMessageRef } : {});
+            });
             let response = '';
             let context = { prompt: '', decisions: [], hasContext: false };
             let streamFlushTimer = null;
@@ -948,7 +891,6 @@ This protects your credentials from being exposed in chat logs.`;
                 // CONTINUE turns: Codex server retains full conversation via threadId,
                 // so skip expensive prompt rebuilding (embedding search, DB history, etc.)
                 let systemPrompt;
-                let ownerReportHistoryPrompt = '';
                 const historyContext = message.metadata?.historyContext;
                 // Public turns never inspect private workspace rules, skills, or AGENTS files.
                 const enhanced = isPublicLane
@@ -957,7 +899,13 @@ This protects your credentials from being exposed in chat logs.`;
                 // TG-05: every main backend keeps its live conversation in a durable
                 // runtime session. Only a genuinely new/replacement session rebuilds
                 // bounded MAMA context.
-                const needsFullContext = isNewCliSession;
+                // The in-memory SessionPool is empty after a daemon restart, while a
+                // durable Codex thread may still be alive. Codex first attempts that
+                // thread with a minimal continuation; AgentLoop invokes the lazy full
+                // builder only when the registry says the thread is actually missing.
+                const lazyDurableResume = runtimeOwnsSession ||
+                    (this.config.backend === 'codex' && this.agentLoop.probesDurableSession === true);
+                const needsFullContext = isNewCliSession && !lazyDurableResume;
                 // Persistent backends skip repeated retrieval after the first turn.
                 context =
                     !isPublicLane && needsFullContext && this.config.implicitLegacyContextSearch
@@ -982,8 +930,8 @@ This protects your credentials from being exposed in chat logs.`;
                             source: message.source,
                             channelId: message.channelId,
                         });
-                        systemPrompt = this.buildSystemPrompt(session, context.prompt, historyContext, sessionStartupContext, agentContext, enhanced, true, trelloAvailable);
-                        ownerReportHistoryPrompt = this.buildOwnerReportHistoryPrompt(session);
+                        systemPrompt = this.buildSystemPrompt(session, context.prompt, historyContext, sessionStartupContext, agentContext, enhanced, !(runtimeSessionKey === owner_runtime_js_1.OWNER_RUNTIME_SESSION_KEY &&
+                            this.agentLoop.ownerRecoveryJournalEnabled === true), trelloAvailable);
                     }
                 }
                 // 7. Run agent loop (with session info for lane-based concurrency)
@@ -1018,13 +966,14 @@ This protects your credentials from being exposed in chat logs.`;
                 // After a daemon restart the pool is new, but the durable Codex thread may
                 // still exist and should be resumed. Keep prompt/context freshness separate
                 // from backend conversation continuity.
-                const shouldResumeBackend = this.config.backend === 'codex' ? true : shouldResume;
+                const shouldResumeBackend = runtimeOwnsSession || this.config.backend === 'codex' ? true : shouldResume;
+                const usesContinuationContext = shouldResume || lazyDurableResume;
                 // For resumed sessions: inject minimal context only
                 // Persistent CLI keeps the process alive with full system prompt from initial request
                 // Only inject per-message context (related decisions) to avoid context overflow
                 const effectivePrompt = isPublicLane
                     ? publicLaneBaseInstructions
-                    : shouldResume
+                    : usesContinuationContext
                         ? this.buildMinimalResumePrompt(context.prompt, agentContext)
                         : systemPrompt;
                 // Wrap stream callbacks to accumulate deltas and periodically flush to DB
@@ -1047,7 +996,6 @@ This protects your credentials from being exposed in chat logs.`;
                         }
                     }, streamFlushIntervalMs);
                 }
-                let parentModelRunId;
                 // Skill on-demand injection: prepend matched skill content to user message
                 // (not system prompt — PersistentCLI can't update system prompt after creation)
                 const skillPrefix = !isPublicLane && enhanced.skillContent
@@ -1067,22 +1015,28 @@ This protects your credentials from being exposed in chat logs.`;
                 let pendingNotices = false;
                 let pendingChannelNoticeCount = 0;
                 let pendingBroadcastNoticeCount = 0;
-                const envelope = this.buildReactiveEnvelope(message, agentContext, memberEffectiveScope);
+                const envelope = runtimeOwnsSession
+                    ? undefined
+                    : this.buildReactiveEnvelope(message, agentContext, memberEffectiveScope);
                 const options = {
                     systemPrompt: effectivePrompt,
-                    ...(ownerReportHistoryPrompt ? { ownerReportHistoryPrompt } : {}),
                     sessionPolicyFingerprint,
                     ...(memberEffectiveScope ? { memberEffectiveScope } : {}),
                     ...(memberEffectiveScope ? { memberScopeRequired: true } : {}),
                     userId: message.userId,
                     model: roleModel, // Role-specific model override
                     maxTurns: roleMaxTurns, // Role-specific max turns
-                    sessionKey: channelKey,
+                    sessionKey: runtimeSessionKey,
+                    ...(runtimeSessionKey === owner_runtime_js_1.OWNER_RUNTIME_SESSION_KEY ? { lanePriority: 100 } : {}),
                     source: message.source,
                     channelId: message.channelId,
                     agentContext,
+                    ...(runtimeSessionKey === owner_runtime_js_1.OWNER_RUNTIME_SESSION_KEY
+                        ? { sessionPolicyRole: ownerRuntimeRole }
+                        : {}),
                     resumeSession: shouldResumeBackend,
-                    cliSessionId, // Pass CLI session ID to avoid double-locking
+                    // Queued owner input must not claim a busy session or pin a stale pool id.
+                    ...(runtimeOwnsSession ? {} : { cliSessionId }),
                     // AgentLoop may replace a stale backend session while this request still
                     // owns the channel lock. Keep cleanup guarded by the current owner ID.
                     onCliSessionReset: (sessionId) => {
@@ -1090,8 +1044,16 @@ This protects your credentials from being exposed in chat logs.`;
                     },
                     streamCallbacks: wrappedOnStream || processOptions?.onStream,
                     envelope,
+                    ...(runtimeOwnsSession
+                        ? {
+                            prepareEnvelope: () => this.buildReactiveEnvelope(message, agentContext, memberEffectiveScope),
+                        }
+                        : {}),
                     sourceTurnId,
                     sourceMessageRef,
+                    ...(runtimeSessionKey === owner_runtime_js_1.OWNER_RUNTIME_SESSION_KEY
+                        ? { ownerJournalPrompt: message.text, ownerJournalTrust: 'owner' }
+                        : {}),
                     // The owner's message is what caused whatever this turn changes, and the router
                     // knows it BEFORE the agent runs - the same shape as a reconcile work order
                     // carrying its delta batch. Without this the chat lane had no cause wire at all:
@@ -1104,7 +1066,7 @@ This protects your credentials from being exposed in chat logs.`;
                     // citation this ledger exists to refuse.
                     ...(causeFromOwnerMessage(sourceTurnId, sourceMessageRef) ?? {}),
                 };
-                if (shouldResume) {
+                if (shouldResumeBackend) {
                     options.freshSessionSystemPrompt = async () => {
                         if (isPublicLane) {
                             return memberEffectiveScope
@@ -1118,27 +1080,21 @@ This protects your credentials from being exposed in chat logs.`;
                             source: message.source,
                             channelId: message.channelId,
                         });
-                        return this.buildSystemPrompt(session, freshContext.prompt, historyContext, sessionStartupContext, agentContext, enhanced, true, trelloAvailable);
+                        return this.buildSystemPrompt(session, freshContext.prompt, historyContext, sessionStartupContext, agentContext, enhanced, !(runtimeSessionKey === owner_runtime_js_1.OWNER_RUNTIME_SESSION_KEY &&
+                            this.agentLoop.ownerRecoveryJournalEnabled === true), trelloAvailable);
                     };
-                    if (!isPublicLane) {
-                        options.freshSessionOwnerReportHistoryPrompt = () => this.buildOwnerReportHistoryPrompt(session);
-                    }
                 }
-                if (shouldResume) {
+                if (usesContinuationContext) {
                     logger.info(`Resuming CLI session (minimal: ${effectivePrompt.length} chars)`);
                 }
                 else {
                     logger.info(`New CLI session (full: ${systemPrompt.length} chars)`);
                 }
-                // TG-05/TG-06: carry is captured once before the model call and travels
-                // only in this turn's user message, never in a rebuilt system prompt.
-                const carryPrefix = !isPublicLane ? (reportCarryPeek?.prefix ?? '') : '';
-                const inboxPrefix = !isPublicLane && ownerReportSnapshot ? `${ownerReportSnapshot.text}\n\n` : '';
                 try {
                     if (isPublicLane) {
                         memoryPrefix = '';
                     }
-                    else if (shouldResume) {
+                    else if (usesContinuationContext) {
                         // Per-channel notices PLUS the operator broadcast key: host-code
                         // alarms (workorder failures) have no conversation channel at
                         // enqueue time - without the broadcast read they dead-letter
@@ -1166,7 +1122,7 @@ This protects your credentials from being exposed in chat logs.`;
                 }
                 catch (err) {
                     logger.warn(`[memory-prefix] Failed: ${err instanceof Error ? err.message : String(err)}`);
-                    if (!isPublicLane && shouldResume) {
+                    if (!isPublicLane && usesContinuationContext) {
                         try {
                             memoryPrefix = await this.getPerTurnMemoryPrefix(message);
                         }
@@ -1212,7 +1168,7 @@ This protects your credentials from being exposed in chat logs.`;
                     }
                     // Add text content (with memory context, skill context, and page context)
                     const pageCtx = isPublicLane ? '' : this.getPageContextPrefix(message);
-                    const effectiveMessageText = `${pageCtx}${inboxPrefix}${carryPrefix}${memoryPrefix}${learningPrefix}${skillPrefix}${messageText || ''}`;
+                    const effectiveMessageText = `${pageCtx}${memoryPrefix}${learningPrefix}${skillPrefix}${messageText || ''}`;
                     if (effectiveMessageText) {
                         contentBlocks.push({ type: 'text', text: effectiveMessageText });
                     }
@@ -1247,48 +1203,27 @@ This protects your credentials from being exposed in chat logs.`;
                     const turnStart = Date.now();
                     const result = await this.agentLoop.runWithContent(contentBlocks, options);
                     response = result.response;
-                    parentModelRunId = result.modelRunId ?? undefined;
                     completedModelRunId = result.modelRunId ?? completedModelRunId;
                     if (result.modelRunProvenance === 'commit_failed') {
                         completedProvenanceReason = 'commit_failed';
                     }
+                    completedOwnerJournalProvenance = result.ownerJournalProvenance;
                     this.logFrontdoorActivity(message, message.text, response, Date.now() - turnStart);
                 }
                 else {
                     const pageCtx = isPublicLane ? '' : this.getPageContextPrefix(message);
-                    const effectiveText = `${pageCtx}${inboxPrefix}${carryPrefix}${memoryPrefix}${learningPrefix}${skillPrefix}${message.text}`;
+                    const effectiveText = `${pageCtx}${memoryPrefix}${learningPrefix}${skillPrefix}${message.text}`;
                     const turnStart = Date.now();
                     const result = await this.agentLoop.run(effectiveText, options);
                     response = result.response;
-                    parentModelRunId = result.modelRunId ?? undefined;
                     completedModelRunId = result.modelRunId ?? completedModelRunId;
                     if (result.modelRunProvenance === 'commit_failed') {
                         completedProvenanceReason = 'commit_failed';
                     }
+                    completedOwnerJournalProvenance = result.ownerJournalProvenance;
                     this.logFrontdoorActivity(message, message.text, response, Date.now() - turnStart);
                 }
-                // Auto-extract facts from conversation (fire-and-forget, non-blocking).
-                // Dual-save dedup: when the agent ALREADY persisted memory during this
-                // turn (gateway mama_save in the reasoning header), the extractor safety
-                // net would save the same instruction twice (proven live 2026-07-17:
-                // decision_* + mem_* duplicates for one directive). The in-turn save is
-                // the agent's judgment; the net exists for turns where it did not act.
-                const agentSavedThisTurn = agentSavedInTurn(response);
-                if (agentSavedThisTurn) {
-                    logger.info('[memory-agent] extraction skipped - agent saved in-turn (dual-save dedup)');
-                }
-                if (!isPublicLane && response && message.text && !agentSavedThisTurn) {
-                    const rawAssistantText = stripGatewayDecorations(response);
-                    void (async () => {
-                        try {
-                            await this.triggerMemoryAgent(channelKey, message.text, rawAssistantText, message, sourceTurnId, sourceMessageRef, parentModelRunId);
-                        }
-                        catch {
-                            /* non-fatal */
-                        }
-                    })();
-                }
-                if (shouldResume && pendingNotices) {
+                if (usesContinuationContext && pendingNotices) {
                     // Drain each queue by ITS OWN peeked count - notices enqueued while
                     // the agent run was in flight stay for the next turn (review N2).
                     if (pendingChannelNoticeCount > 0) {
@@ -1312,7 +1247,7 @@ This protects your credentials from being exposed in chat logs.`;
                     normalizedErrorMsg.includes('exited with code');
                 if (isCriticalError) {
                     logger.warn(`CLI error detected, invalidating session: ${errorMsg}`);
-                    sessionPool.invalidateSession(channelKey, cliSessionId);
+                    sessionPool.invalidateSession(runtimeSessionKey, cliSessionId);
                 }
                 // Release session lock before re-throwing
                 releaseCliSessionLock();
@@ -1358,36 +1293,14 @@ This protects your credentials from being exposed in chat logs.`;
                 });
             }
             // 6. Update session context — finalize assistant response
-            if (ownerReportSnapshot) {
-                // TG-05 (design Decision 6): the final turn, its receipt, and the
-                // consumption marks commit in ONE SQLite transaction. A failure here
-                // MUST surface - no report caller may swallow persistence failure and
-                // report success.
-                this.sessionStore.finalizeTurnWithReportReceipt({
-                    sessionId: session.id,
-                    sourceMessageRef,
-                    finalResponse: response,
-                    committedAtIso: new Date().toISOString(),
-                    receipt: {
-                        deliveryIds: ownerReportSnapshot.deliveryIds,
-                        projectionVersion: ownerReportSnapshot.version,
-                        projectionText: ownerReportSnapshot.text,
-                        projectionHash: ownerReportSnapshot.projectionHash,
-                    },
+            const persisted = this.sessionStore.flushStreamingResponse(session.id, response) ||
+                this.sessionStore.appendMessage(session.id, {
+                    role: 'assistant',
+                    content: response,
+                    timestamp: Date.now(),
                 });
-            }
-            else {
-                // Use flushStreamingResponse first (updates existing turn from periodic flush),
-                // fall back to appendMessage if no turn exists yet (non-streaming path)
-                const persisted = this.sessionStore.flushStreamingResponse(session.id, response) ||
-                    this.sessionStore.appendMessage(session.id, {
-                        role: 'assistant',
-                        content: response,
-                        timestamp: Date.now(),
-                    });
-                if (!persisted) {
-                    throw new Error('Unable to persist final assistant response');
-                }
+            if (!persisted) {
+                throw new Error('Unable to persist final assistant response');
             }
             if ((message.principal?.lane ?? 'owner') !== 'public' &&
                 response &&
@@ -1400,19 +1313,6 @@ This protects your credentials from being exposed in chat logs.`;
                     logger.warn(`[learning] observer failed: ${error instanceof Error ? error.message : String(error)}`);
                 });
             }
-            if (reportCarryPeek && reportCarryTarget && reportCarryChannelKey) {
-                try {
-                    this.reportCarry?.acknowledge({
-                        deliveryId: reportCarryPeek.deliveryId,
-                        target: reportCarryTarget,
-                        consumingChannelKey: reportCarryChannelKey,
-                        consumedAtIso: new Date().toISOString(),
-                    });
-                }
-                catch (error) {
-                    logger.warn(`[report-carry] acknowledgement failed: ${error instanceof Error ? error.message : String(error)}`);
-                }
-            }
             // Release session lock AFTER final persistence to prevent out-of-order turns
             releaseCliSessionLock();
             // 6. Return result. Run identity rides out with it: the router already generated
@@ -1429,6 +1329,14 @@ This protects your credentials from being exposed in chat logs.`;
                     : { status: 'unavailable', reason: completedProvenanceReason },
                 sourceTurnId,
                 sourceMessageRef,
+                ...(completedOwnerJournalProvenance
+                    ? {
+                        recoveryProvenance: {
+                            status: 'unavailable',
+                            reason: 'journal_commit_failed',
+                        },
+                    }
+                    : {}),
             };
         }
         finally {
@@ -1572,22 +1480,6 @@ ${historyContext}
         }
         return this.projectPrivatePromptText(prompt);
     }
-    /** TG-05 Decision 7: exact receipt history travels as a separate budget layer. */
-    buildOwnerReportHistoryPrompt(session) {
-        if (!this.ownerReportInbox || session.source !== 'telegram') {
-            return '';
-        }
-        const restoredTurns = this.sessionStore
-            .getHistory(session.id)
-            .filter((turn) => turn.state !== 'provisional')
-            .slice(-5);
-        const reportHistory = this.ownerReportInbox.historyBlock({ source: 'telegram', channelId: session.channelId }, restoredTurns);
-        if (!reportHistory) {
-            return '';
-        }
-        logger.info(`Prepared ${reportHistory.length} chars of owner-report history (new session)`);
-        return `## Previously Consumed Owner Reports (reference only)\n${reportHistory}`;
-    }
     buildSessionPolicyFingerprint(agentContext, enhanced, model, trelloAvailable) {
         const baseInstructions = (0, agent_loop_js_1.loadComposedSystemPrompt)(false, agentContext);
         const surface = (0, private_connector_policy_js_1.resolvePrivatePrincipalSurface)({ agentContext });
@@ -1761,145 +1653,9 @@ ${historyContext}
     updateChannelName(source, channelId, channelName) {
         return this.sessionStore.updateChannelName(source, channelId, channelName);
     }
-    /**
-     * Trigger memory agent to extract facts (fire-and-forget).
-     * Uses AgentProcessManager persistent process.
-     */
-    static EXTRACT_COOLDOWN_MS = 30_000;
-    static MIN_CONTENT_LENGTH = 100;
-    static MAX_CONTENT_LENGTH = 10_000;
     getRuntimeProjectId() {
         return process.env.MAMA_WORKSPACE || process.cwd();
     }
-    buildMemoryAuditPrompt(job) {
-        const escapeBackticks = (s) => s.replace(/```/g, '\\`\\`\\`');
-        const scopeContext = job.scopeContext.map((scope) => `${scope.kind}:${scope.id}`).join(', ');
-        const candidateLines = (job.candidates ?? []).map((candidate) => {
-            const topic = candidate.topicHint ? ` topic=${escapeBackticks(candidate.topicHint)}` : '';
-            return `- kind=${candidate.kind}${topic} confidence=${candidate.confidence} summary=${JSON.stringify(candidate.summary)}`;
-        });
-        const safeConversation = escapeBackticks(job.conversation);
-        return `Memory scopes: ${scopeContext}
-Conversation:
-\`\`\`conversation
-${safeConversation}
-\`\`\`
-
-Candidates:
-${candidateLines.length > 0 ? candidateLines.join('\n') : '- none'}
-
-INSTRUCTION:
-- Call mama_search exactly once first.
-- If the conversation contains a decision, preference, fact, lesson, or superseding update, call mama_save exactly once.
-- If nothing should be saved, do not call mama_save.
-- Do not call resource discovery tools.
-- Do not ask follow-up questions.
-- After tool work finishes, respond with exactly DONE or SKIP.`;
-    }
-    classifyMemoryAuditResponse(response) {
-        const normalized = response.trim().toLowerCase();
-        if (normalized.length === 0) {
-            return {
-                status: 'skipped',
-                action: 'no_op',
-                event_ids: [],
-                reason: 'memory agent returned an empty response',
-            };
-        }
-        if (normalized.includes('nothing worth saving') ||
-            normalized.includes('nothing is worth saving') ||
-            normalized.includes('no-op') ||
-            normalized.includes('no op') ||
-            normalized.includes('skip')) {
-            return {
-                status: 'skipped',
-                action: 'no_op',
-                event_ids: [],
-                reason: response,
-            };
-        }
-        if (normalized === 'failed' || normalized.includes('failed')) {
-            return {
-                status: 'failed',
-                action: 'no_op',
-                event_ids: [],
-                reason: response,
-            };
-        }
-        if (normalized === 'done' || normalized === 'applied') {
-            return {
-                status: 'applied',
-                action: 'save',
-                event_ids: [],
-                reason: response,
-            };
-        }
-        return {
-            status: 'skipped',
-            action: 'no_op',
-            event_ids: [],
-            reason: response,
-        };
-    }
-    recordMemoryAuditAck(ack, topic, channelKey, displayTopic, deltaKey) {
-        const timestamp = Date.now();
-        if (ack.status === 'applied') {
-            this.memoryAgentStats.acksApplied++;
-            this.memoryAgentStats.factsSaved++;
-            // Fire-and-forget save confirmation to originating channel
-            if (this.gatewayRegistry && channelKey) {
-                const [source, ...channelParts] = channelKey.split(':');
-                const channelId = channelParts.join(':');
-                const confirmMsg = `✅ Memory saved: ${displayTopic}`;
-                this.gatewayRegistry.sendMessage(source, channelId, confirmMsg).catch((err) => {
-                    logger.warn(`[memory-feedback] Failed to send confirmation: ${err instanceof Error ? err.message : String(err)}`);
-                });
-            }
-        }
-        else if (ack.status === 'skipped') {
-            this.memoryAgentStats.acksSkipped++;
-        }
-        else {
-            this.memoryAgentStats.acksFailed++;
-            logger.warn(`[memory-agent] Audit failed: ${ack.reason ?? 'unknown failure'}`);
-            this.memoryNoticeQueue.enqueue(channelKey ?? 'memory-agent:shared', {
-                type: 'memory_warning',
-                severity: 'high',
-                summary: 'memory audit failed',
-                evidence: [],
-                recommended_action: 'consult_memory',
-                relevant_memories: [],
-            });
-        }
-        this.memoryAgentStats.recentExtractions.unshift({
-            topic,
-            timestamp,
-            channelKey,
-            status: ack.status,
-        });
-        this.memoryAgentStats.recentExtractions = this.memoryAgentStats.recentExtractions.slice(0, 10);
-        this.memoryAgentStats.lastExtraction = timestamp;
-        if (ack.status === 'applied' && channelKey && this.mamaApi.upsertChannelSummary) {
-            const summaryMarkdown = [
-                '## Channel Summary',
-                `- Last memory update: ${displayTopic ?? topic}`,
-                `- Status: ${ack.action}`,
-                ack.reason ? `- Notes: ${ack.reason.slice(0, 240)}` : '',
-            ]
-                .filter(Boolean)
-                .join('\n');
-            void this.mamaApi
-                .upsertChannelSummary({
-                channelKey,
-                summaryMarkdown,
-                deltaHash: `${deltaKey ?? topic}:${ack.action}`,
-            })
-                .catch((error) => {
-                logger.warn(`[channel-summary] Failed: ${error instanceof Error ? error.message : String(error)}`);
-            });
-        }
-    }
-    /** Classify a committed owner message and save a policy:/lesson: row when it carries one. */
     async observeOwnerLearning(message) {
         if (!this.mamaApi.saveMemory || !this.mamaApi.queryRelevantTruth) {
             return;
@@ -1992,131 +1748,6 @@ INSTRUCTION:
         }
         return `[MAMA Memory]\n${context.prompt}\n[/MAMA Memory]\n\n`;
     }
-    async triggerMemoryAgent(channelKey, userText, botResponse, message, sourceTurnId, _sourceMessageRef, parentModelRunId) {
-        const memoryAuditQueue = this.memoryAuditQueue;
-        if (!this.memoryAgentProcessManager || !memoryAuditQueue) {
-            return;
-        }
-        const now = Date.now();
-        const source = message?.source ?? 'memory-agent';
-        const channelId = message?.channelId ?? 'shared';
-        const userId = message?.userId;
-        const candidates = (0, save_candidate_extractor_js_1.extractSaveCandidates)({
-            userText,
-            gatewayWrapped: message?.metadata?.untrustedWrapped === true,
-            botResponse,
-            channelKey,
-            source,
-            channelId,
-            userId,
-            projectId: this.getRuntimeProjectId(),
-            createdAt: now,
-        });
-        const cooldownKey = `${source}:${channelId}:${userId ?? 'anonymous'}`;
-        const lastExtractTime = this.memoryAuditCooldowns.get(cooldownKey) ?? 0;
-        // The cooldown rate-limits memory-agent invocations for ORDINARY chatter.
-        // Candidate-bearing turns are owner directives/decisions - discarding one
-        // because another arrived within 30s loses real instructions, so they
-        // bypass the cooldown (bounded by how fast an owner can type directives).
-        if (candidates.length === 0 && now - lastExtractTime < MessageRouter.EXTRACT_COOLDOWN_MS) {
-            return;
-        }
-        let content = `User: ${userText}\nAssistant: ${botResponse}`;
-        if (content.length < MessageRouter.MIN_CONTENT_LENGTH && candidates.length === 0) {
-            return;
-        }
-        if (content.length > MessageRouter.MAX_CONTENT_LENGTH) {
-            content = content.substring(0, MessageRouter.MAX_CONTENT_LENGTH);
-        }
-        if (candidates.length === 0)
-            return;
-        this.memoryAuditCooldowns.set(cooldownKey, now);
-        // Evict stale cooldown entries (older than 2x cooldown window)
-        if (this.memoryAuditCooldowns.size > 100) {
-            const staleThreshold = now - MessageRouter.EXTRACT_COOLDOWN_MS * 2;
-            for (const [key, ts] of this.memoryAuditCooldowns) {
-                if (ts < staleThreshold)
-                    this.memoryAuditCooldowns.delete(key);
-            }
-        }
-        this.memoryAgentStats.turnsObserved++;
-        this.memoryAgentStats.candidatesDetected += candidates.length;
-        this.memoryAgentStats.factsExtracted += candidates.length;
-        const scopes = (0, scope_context_js_1.deriveMemoryScopes)({
-            source,
-            channelId,
-            userId,
-            projectId: this.getRuntimeProjectId(),
-        });
-        const job = {
-            turnId: sourceTurnId ?? `turn_${now}`,
-            channelKey,
-            source,
-            channelId,
-            userId,
-            parentModelRunId,
-            scopeContext: scopes,
-            conversation: content,
-            candidates,
-        };
-        const rawTopic = userText.slice(0, 40).toLowerCase();
-        const asciiTopic = rawTopic.replace(/[^a-z0-9]+/g, '_').replace(/^_+|_+$/g, '');
-        const topic = asciiTopic || `topic_${(0, node_crypto_1.createHash)('sha256').update(rawTopic).digest('hex').slice(0, 8)}`;
-        const displayTopic = candidates[0]?.topicHint || userText.slice(0, 80).trim() || 'memory_audit';
-        const deltaKeySource = candidates[0]?.id || userText;
-        const deltaKey = (0, node_crypto_1.createHash)('sha256').update(deltaKeySource).digest('hex').slice(0, 16);
-        const memoryStart = Date.now();
-        // Start validation session for memory agent
-        let memValSession = null;
-        if (this.validationService && this.sessionsDb) {
-            try {
-                const ver = (0, agent_store_js_1.getLatestVersion)(this.sessionsDb, 'memory');
-                memValSession = this.validationService.startSession('memory', ver?.version ?? 0, 'audit', {
-                    goal: `Extract: ${displayTopic.slice(0, 100)}`,
-                });
-            }
-            catch {
-                /* non-fatal */
-            }
-        }
-        void (async () => {
-            try {
-                const ack = await memoryAuditQueue.enqueue(job);
-                this.recordMemoryAuditAck(ack, topic, channelKey, displayTopic, deltaKey);
-                const dur = Date.now() - memoryStart;
-                this.logAgentActivity('memory', 'task_complete', displayTopic.slice(0, 200), undefined, dur);
-                if (memValSession && this.validationService) {
-                    try {
-                        this.validationService.finalizeSession(memValSession.id, {
-                            execution_status: 'completed',
-                            metrics: { duration_ms: dur },
-                        });
-                    }
-                    catch {
-                        /* non-fatal */
-                    }
-                }
-            }
-            catch (err) {
-                this.memoryAgentStats.acksFailed++;
-                const dur = Date.now() - memoryStart;
-                this.logAgentActivity('memory', 'task_error', displayTopic.slice(0, 200), undefined, dur, err instanceof Error ? err.message : String(err));
-                if (memValSession && this.validationService) {
-                    try {
-                        this.validationService.finalizeSession(memValSession.id, {
-                            execution_status: 'failed',
-                            error_message: err instanceof Error ? err.message : String(err),
-                            metrics: { duration_ms: dur },
-                        });
-                    }
-                    catch {
-                        /* non-fatal */
-                    }
-                }
-                logger.warn(`[memory-agent] Failed: ${err instanceof Error ? err.message : String(err)}`);
-            }
-        })();
-    }
     // ── Activity Logging (shared by MAMA frontdoor + memory agent) ──────
     resolveFrontdoorAgentId(message) {
         return message.source === 'viewer' ? 'os-agent' : 'mama';