@jungjaehoon/mama-os 0.48.4 → 0.49.1

package/dist/cli/commands/start.js

@@ -65,7 +65,6 @@ exports.buildTurnAgentPolicy = buildTurnAgentPolicy;
 exports.bindCodeActParentModelRun = bindCodeActParentModelRun;
 exports.finalizeCodeActParentModelRun = finalizeCodeActParentModelRun;
 exports.failCodeActParentModelRun = failCodeActParentModelRun;
-exports.buildSystemAgentProcessDefaults = buildSystemAgentProcessDefaults;
 exports.resolveOwnerEventTerminalReceipt = resolveOwnerEventTerminalReceipt;
 exports.startCommand = startCommand;
 exports.buildStartOnboardingOutput = buildStartOnboardingOutput;
@@ -85,7 +84,6 @@ const run_context_registry_js_1 = require("../../agent/code-act/run-context-regi
 const index_js_2 = require("../../gateways/index.js");
 const member_effective_scope_js_1 = require("../../gateways/member-effective-scope.js");
 const telegram_report_context_store_js_1 = require("../../gateways/telegram-report-context-store.js");
-const owner_report_inbox_js_1 = require("../../gateways/owner-report-inbox.js");
 const report_delivery_coordinator_js_1 = require("../../operator/report-delivery-coordinator.js");
 const graph_api_js_1 = require("../../api/graph-api.js");
 const sqlite_js_1 = __importDefault(require("../../sqlite.js"));
@@ -104,7 +102,6 @@ const daemon_js_1 = require("../runtime/daemon.js");
 const metrics_init_js_1 = require("../runtime/metrics-init.js");
 const mama_core_init_js_1 = require("../runtime/mama-core-init.js");
 const agent_loop_init_js_1 = require("../runtime/agent-loop-init.js");
-const memory_agent_init_js_1 = require("../runtime/memory-agent-init.js");
 const gateway_init_js_1 = require("../runtime/gateway-init.js");
 const gateway_wiring_js_1 = require("../runtime/gateway-wiring.js");
 const scheduler_init_js_1 = require("../runtime/scheduler-init.js");
@@ -127,12 +124,7 @@ 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 mamaCore = __importStar(require("@jungjaehoon/mama-core"));
-const report_run_js_1 = require("../../operator/report-run.js");
-const report_context_js_1 = require("../../operator/report-context.js");
-const changes_projection_js_1 = require("../../operator/changes-projection.js");
-const external_correlation_js_1 = require("../../operator/external-correlation.js");
-const provenance_lookup_js_1 = require("../../operator/provenance-lookup.js");
-const query_tools_js_1 = require("../../connectors/trello/query-tools.js");
+const owner_runtime_js_1 = require("../../operator/owner-runtime.js");
 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");
@@ -488,7 +480,6 @@ exports.ADMINISTRATION_TOOLS = new Set([
     'member_scope_grant',
     'member_scope_revoke',
     'console_brief_update',
-    'report_request',
 ]);
 /**
  * Per-turn-kind artifact tools, projected by the HOST. These exist only for scheduled
@@ -613,15 +604,23 @@ exports.TURN_KIND_BLOCKED_TOOLS = {
         'obsidian',
     ]),
 };
-/**
- * Packet-only reports receive no gateway tools. The host compiles current bounded authorities
- * before model admission; the model spends one turn judging and narrating that packet.
- */
+/** Progressive evidence primitives for a scheduled owner-runtime report turn. */
 exports.OPERATOR_REPORT_TOOL_POLICY = {
-    roleName: 'operator-report',
-    // TG-03/TG-04/TG-05: the model judges one host-compiled packet. It does not rediscover
-    // current state or mutate another projection during report composition.
-    allowedTools: [],
+    roleName: 'owner_console',
+    allowedTools: [
+        'code_act',
+        'task_list',
+        'changes_read',
+        'board_read',
+        'audit_findings_read',
+        'schedule_upcoming',
+        'context_compile',
+        'mama_recall',
+        'mama_provenance',
+        'trello_search',
+        'trello_card',
+        'trello_kanban',
+    ],
 };
 function requirePrivateConnectorPolicy(privateConnectorPolicy) {
     if (!privateConnectorPolicy) {
@@ -646,26 +645,36 @@ function buildProjectedLanePrompt(innerTools, surface, privateConnectorPolicy) {
     }).prompt;
 }
 /**
- * Build the deliberately tool-free role for one packet-only report turn.
+ * Build the execution role for one progressive report stimulus. The durable
+ * session catalog comes from the full owner role; this role narrows effects.
  */
-function buildOperatorReportAgentPolicy(model, backend, privateConnectorPolicy) {
+function buildOperatorReportAgentPolicy(model, backend, privateConnectorPolicy, ownerRole = types_js_1.DEFAULT_ROLES.definitions.owner_console) {
     const requiredPrivatePolicy = requirePrivateConnectorPolicy(privateConnectorPolicy);
-    const blockedTools = [];
-    const allowedTools = [];
-    const projectedRole = {
-        allowedTools,
-        blockedTools,
-        allowedPaths: [],
-        systemControl: false,
-        sensitiveAccess: false,
-    };
+    const blockedSet = new Set([
+        ...exports.ADMINISTRATION_TOOLS,
+        ...exports.SCHEDULED_TURN_BLOCKED_TOOLS,
+        ...(ownerRole.blockedTools ?? []),
+    ]);
+    const projectedRole = requiredPrivatePolicy.projectRole('owner_console', {
+        ...ownerRole,
+        model,
+        allowedTools: uniqueToolList([
+            ...ownerRole.allowedTools,
+            ...exports.OPERATOR_REPORT_TOOL_POLICY.allowedTools,
+        ]).filter((tool) => !blockedSet.has(tool)),
+        blockedTools: [...blockedSet],
+        allowedPaths: [...(ownerRole.allowedPaths ?? [])],
+    });
+    const blockedTools = [...new Set([...(projectedRole.blockedTools ?? []), ...blockedSet])];
+    const innerTools = uniqueToolList(projectedRole.allowedTools).filter((tool) => tool !== 'code_act' && !blockedSet.has(tool));
+    const allowedTools = uniqueToolList(['code_act', ...innerTools]);
     const agentContext = {
         source: 'operator',
         platform: 'cli',
-        roleName: exports.OPERATOR_REPORT_TOOL_POLICY.roleName,
+        roleName: exports.ONE_AGENT_TURN_POLICY.roleName,
         role: { ...projectedRole, allowedTools, blockedTools, model },
         session: {
-            sessionId: report_run_js_1.OPERATOR_REPORT_SESSION_KEY,
+            sessionId: owner_runtime_js_1.OWNER_RUNTIME_SESSION_KEY,
             channelId: 'report',
             startedAt: new Date(),
         },
@@ -676,7 +685,7 @@ function buildOperatorReportAgentPolicy(model, backend, privateConnectorPolicy)
     };
     return {
         agentContext,
-        gatewayToolsPrompt: '',
+        gatewayToolsPrompt: buildProjectedLanePrompt(innerTools, 'owner_console', requiredPrivatePolicy),
         briefProjectionPolicy: requiredPrivatePolicy,
     };
 }
@@ -718,7 +727,7 @@ function buildTurnAgentPolicy(kind, model, backend, privateConnectorPolicy, rawC
         roleName: exports.ONE_AGENT_TURN_POLICY.roleName,
         role: { ...projectedRole, allowedTools, blockedTools, model },
         session: {
-            sessionId: `operator:worker:${kind}`,
+            sessionId: owner_runtime_js_1.OWNER_RUNTIME_SESSION_KEY,
             channelId: `worker:${kind}`,
             startedAt: new Date(),
         },
@@ -782,11 +791,6 @@ function failCodeActParentModelRun(adapter, modelRunId, error) {
     }
     (0, mama_core_1.failModelRunInAdapter)(adapter, modelRunId, codeActErrorSummary(error));
 }
-function buildSystemAgentProcessDefaults(config) {
-    return {
-        dangerouslySkipPermissions: config.multi_agent?.dangerouslySkipPermissions ?? true,
-    };
-}
 function resolveOwnerEventTerminalReceipt(batch, deps) {
     // Crash-recovery mirror of classifyOwnerEventOutcome. A ledger write that
     // named this batch's events as its cause (evidence_effects) or a confirmed
@@ -903,7 +907,7 @@ async function printStartOnboardingStatus() {
  * Phase  1: Foundation (config, db, oauth, metrics)
  * Phase  2: Session + Tool + Agent Loop
  * Phase  3: MAMA Core API
- * Phase  4: Memory Agent + MessageRouter
+ * Phase  4: MessageRouter
  * Phase  5: Graph Handler + Embedding
  * Phase  6: Cron Scheduler
  * Phase  7: Gateways
@@ -920,7 +924,7 @@ async function runAgentLoop(config, options = {}) {
     const runtimeBackend = requireRuntimeBackend(config.agent.backend);
     const { connectorConfigLoadResult, privateConnectorPolicy } = (0, connector_bootstrap_js_1.resolveRuntimeConnectorBootstrap)((0, config_loader_js_1.loadConnectorConfig)());
     // ONE owner role for every model turn: chat, event, and scheduled.
-    const ownerRole = config.roles?.definitions.owner_console ?? types_js_1.DEFAULT_ROLES.definitions.owner_console;
+    const ownerRole = (0, owner_runtime_js_1.projectOwnerRuntimeRole)(config.roles?.definitions.owner_console ?? types_js_1.DEFAULT_ROLES.definitions.owner_console);
     const temporalPolicy = temporalStartup.temporalFlag === 'on'
         ? buildTurnAgentPolicy('temporal', config.agent.model, runtimeBackend, privateConnectorPolicy, [], ownerRole)
         : null;
@@ -967,15 +971,9 @@ async function runAgentLoop(config, options = {}) {
     const { metricsStore, metricsCleanup, healthService, healthCheckService, metricsInterval } = await (0, metrics_init_js_1.initMetrics)(config, db, utilities_js_1.EMBEDDING_PORT);
     // ── Phase 2: Session + Tool + Agent Loop ──────────────────────────────────
     const sessionStore = new index_js_2.SessionStore(db);
-    // TG-05/TG-06: the messenger SQLite database is the single owner-report
-    // context authority. One store instance on the SAME connection as
-    // SessionStore, so turn finalization and report consumption share one
-    // transaction (design Decision 4/6).
-    const reportContextStore = new telegram_report_context_store_js_1.TelegramReportContextStore(db, {
-        // TG-05 Slice K: one-time V2 carry migration; the file is renamed
-        // `.migrated` after commit and no component reads or writes V2 afterward.
-        legacyCarryPath: (0, config_manager_js_1.expandPath)('~/.mama/operator/last-full-report.json'),
-    });
+    // TG-05/TG-06: durable report delivery ledger. Conversation continuity is
+    // owned by the standing owner runtime, so this store never injects reports.
+    const reportContextStore = new telegram_report_context_store_js_1.TelegramReportContextStore(db);
     // Establish one canonical private workspace for gateway files, OCR, Drive,
     // Telegram media, and the persona runtime. An explicit environment override
     // remains authoritative; otherwise honor config.workspace.path.
@@ -1040,16 +1038,15 @@ async function runAgentLoop(config, options = {}) {
         memberGrantReader: principalRegistry,
         dependencies: {
             privateConnectorPolicy,
-            // TG-05 (design Decision 8): the V2 carry reader is NOT wired - the
-            // boot-time migration owns last-full-report.json, and no component
-            // reads or writes V2 afterward. Wiring FileReportCarryStore here would
-            // couple two owners to one file behind an implicit construction order.
-            ownerReportInbox: new owner_report_inbox_js_1.OwnerReportInbox(reportContextStore),
+            // Report delivery is receipted by the delivery ledger. Conversation
+            // recovery belongs only to the owner-runtime journal.
         },
     });
     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, agentLoopBackend, toolExecutor);
+    // One MAMA: memory judgment stays in the owner turn through mama_save and
+    // deterministic owner-policy observation. Do not boot a second model identity
+    // that re-reads every conversation after the owner agent has answered.
     // ── Phase 5: Graph Handler + Embedding ────────────────────────────────────
     // Create singleton UI command queue for Agent↔Viewer communication
     const uiCommandQueue = new ui_command_handler_js_1.UICommandQueue();
@@ -1057,7 +1054,6 @@ async function runAgentLoop(config, options = {}) {
     const graphHandlerOptions = {
         healthService: healthService ?? undefined,
         healthCheckService,
-        auditConversation: (job) => messageRouter.auditConversation(job),
         sessionsDb: db,
         uiCommandQueue,
     };
@@ -1291,7 +1287,74 @@ async function runAgentLoop(config, options = {}) {
     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);
+    const backgroundOwnerContext = (0, owner_event_policy_js_1.buildOwnerEventAgentContext)({
+        backend: runtimeBackend,
+        model: config.agent.model,
+        ownerRole,
+        privateConnectorPolicy,
+    });
+    const issueOwnerRuntimeEnvelope = async (channelId, wallSeconds) => {
+        if (!envelopeBootstrap.envelopeAuthority || envelopeBootstrap.metadata.issuance === 'off') {
+            return undefined;
+        }
+        const projectId = (0, reactive_config_js_1.resolveReactiveProjectRoot)(config, process.env);
+        return envelopeBootstrap.envelopeAuthority.buildAndPersist({
+            agent_id: 'mama-owner',
+            instance_id: (0, node_crypto_1.randomUUID)(),
+            source: 'cron',
+            channel_id: channelId,
+            trigger_context: { user_text: `<owner runtime ${channelId} stimulus>` },
+            scope: {
+                project_refs: [{ kind: 'project', id: projectId }],
+                raw_connectors: [
+                    ...privateConnectorPolicy.projectRawConnectors('owner_console', codeActRawConnectors),
+                ],
+                memory_scopes: uniqueMemoryScopes((0, scope_context_js_1.deriveMemoryScopes)({ source: 'operator', channelId, projectId })),
+                allowed_destinations: [],
+            },
+            tier: 1,
+            budget: { wall_seconds: wallSeconds },
+            expires_at: new Date(Date.now() + wallSeconds * 1000 + 30_000).toISOString(),
+        });
+    };
+    const runOwnerStimulus = async (content, channelId) => {
+        return await agentLoop.run(content, {
+            sessionKey: owner_runtime_js_1.OWNER_RUNTIME_SESSION_KEY,
+            source: 'operator',
+            channelId,
+            agentContext: backgroundOwnerContext,
+            sessionPolicyRole: ownerRole,
+            prepareEnvelope: async () => {
+                const envelope = await issueOwnerRuntimeEnvelope(channelId, 600);
+                if (!envelope)
+                    throw new Error(`Owner runtime stimulus ${channelId} requires envelope authority`);
+                return envelope;
+            },
+            requestTimeoutMs: 600_000,
+        });
+    };
+    const cronOwnerRunner = {
+        backendType: runtimeBackend,
+        prompt: async (content) => {
+            const result = await runOwnerStimulus(content, 'cron');
+            return {
+                response: result.response,
+                usage: result.totalUsage,
+                session_id: owner_runtime_js_1.OWNER_RUNTIME_SESSION_KEY,
+            };
+        },
+        setSessionId: () => { },
+        setSystemPrompt: () => { },
+        isHealthy: () => true,
+        getMetrics: () => ({
+            requestCount: 0,
+            failureCount: 0,
+            avgLatencyMs: 0,
+            lastRequestAt: null,
+        }),
+        stop: () => { },
+    };
+    const { scheduler, cronWorker, cronEmitter } = (0, scheduler_init_js_1.initCronScheduler)(config, () => cronOwnerRunner);
     // ── Phase 7: Gateways ────────────────────────────────────────────────────
     const gatewayInit = await (0, gateway_init_js_1.initGateways)(config, messageRouter, toolExecutor, agentLoop, runtimeBackend, db, principalResolver);
     const { discordGateway, slackGateway, telegramGateway, gateways } = gatewayInit;
@@ -1309,44 +1372,14 @@ async function runAgentLoop(config, options = {}) {
         agentLoop,
         cronEmitter,
     });
-    // ── Phase 8.5: Delegate tool fallback wiring ─────────────────────────────
-    // If no Discord/Slack handler wired the delegate tool, create standalone
-    // DelegationManager + AgentProcessManager so delegate() works from any path
-    // (Viewer, Telegram, iMessage, Terminal).
-    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 pm = new AgentProcessManager(fallbackMultiAgentConfig, buildSystemAgentProcessDefaults(config), {
-            backend: runtimeBackend,
-            model: config.agent.model,
-            effort: config.agent.effort,
-            clineCwd: workspaceRoot,
-            clineCommand: process.env.MAMA_CLINE_COMMAND ?? config.agent.cline_command,
-            clineProvider: config.agent.cline_provider,
-            clineDataDir: config.agent.cline_data_dir,
-            privateConnectorPolicy,
-        });
-        toolExecutor.setAgentProcessManager(pm);
-        agentLoop.setAgentProcessManager(pm);
-        graphHandlerOptions.applyMultiAgentConfig = async (rawConfig) => {
-            const nextConfig = rawConfig;
-            pm.updateConfig(nextConfig);
-        };
-        graphHandlerOptions.restartMultiAgentAgent = async (agentId) => {
-            pm.reloadPersona(agentId);
-        };
-        // The delegate wiring was here. Over the full log history it was wired ZERO times and
-        // its only runtime trace was one call refused by role permission. The process manager
-        // above stays: that one IS wired on every boot (113 so far) and runs the dashboard and
-        // wiki agents.
-        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 { heartbeatScheduler, tokenKeepAlive, healthWarningInterval } = (0, scheduler_init_js_1.initHeartbeat)(config, agentLoop, discordGateway, scheduler, healthCheckService, async () => {
+        return {
+            agentContext: backgroundOwnerContext,
+            sessionPolicyRole: ownerRole,
+            prepareEnvelope: () => issueOwnerRuntimeEnvelope('heartbeat', 300),
+        };
+    });
     // 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
@@ -1668,15 +1701,11 @@ async function runAgentLoop(config, options = {}) {
                     reconcileChannelKey,
                     privateConnectorPolicy,
                 });
-                // Worker prompt selects the provider's supported tool path: Claude's
-                // text gateway or Codex's injected native host tools. Both avoid the
-                // spawn-default code-act path, where per-run envelope/capture overrides
-                // cannot reach (shadow-gate §8.2).
-                const { buildWorkerSystemPrompt } = await import('../../operator/worker-run.js');
                 const workOrderPolicy = buildTurnAgentPolicy(wo.workKind, config.agent.model, runtimeBackend, privateConnectorPolicy, workOrderScope.raw_connectors, ownerRole);
                 const runOptions = attachWorkOrderAttemptContext({
-                    systemPrompt: buildWorkerSystemPrompt(workOrderPolicy.gatewayToolsPrompt, runtimeBackend, wo.workKind),
+                    gatewayToolsPrompt: workOrderPolicy.gatewayToolsPrompt,
                     agentContext: workOrderPolicy.agentContext,
+                    sessionPolicyRole: ownerRole,
                     workOrderBriefProjectionPolicy: workOrderPolicy.briefProjectionPolicy,
                 }, wo.id);
                 // A temporal run is bound to ONE task on ONE channel, and the packet check
@@ -1729,7 +1758,8 @@ async function runAgentLoop(config, options = {}) {
                 // failure rejects -> failWorkOrder (no envelope-less fallback run).
                 if (envelopeBootstrap.envelopeAuthority && envelopeBootstrap.metadata.issuance !== 'off') {
                     const wallSeconds = Math.min(Math.max(Number(process.env.MAMA_REPORT_WALL_SECONDS) || 900, 60), 1800);
-                    runOptions.envelope = await envelopeBootstrap.envelopeAuthority.buildAndPersist({
+                    const workOrderEnvelopeAuthority = envelopeBootstrap.envelopeAuthority;
+                    runOptions.prepareEnvelope = () => workOrderEnvelopeAuthority.buildAndPersist({
                         agent_id: 'mama-owner',
                         instance_id: (0, node_crypto_1.randomUUID)(),
                         // 'watch' = daemon-internal issuing source (closed EnvelopeSource
@@ -1824,7 +1854,6 @@ async function runAgentLoop(config, options = {}) {
     // 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)) {
-        let stopTriggerAgentRuntime;
         // 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
@@ -1834,7 +1863,6 @@ async function runAgentLoop(config, options = {}) {
             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 { createTriggerAgentRuntime } = await import('../../operator/trigger-author.js');
             const { reviewTriggerCLI } = await import('../../operator/trigger-review.js');
             const { ReportScheduler, FileReportScheduleStore, parseReportHours } = await import('../../operator/report-scheduler.js');
             // Set when a report is composed, read when that same report is delivered. Safe
@@ -1851,10 +1879,9 @@ async function runAgentLoop(config, options = {}) {
             // 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 = resolveOperatorReportChatId(process.env, config.telegram?.allowed_chats);
-            // TG-05/TG-06 (design Decision 1): ONE production boundary for all
-            // owner-report modes. The legacy OutputSink + V2 carry writer are out of
-            // production assembly; the SQLite report-context store owns carry and
-            // the coordinator owns every Telegram send.
+            // TG-05/TG-06: one durable production boundary for every report mode.
+            // The delivery ledger reserves exact output and the coordinator owns
+            // every Telegram send; no report text is copied into another model.
             let reportDelivery;
             const reportTarget = reportChatId && telegramGateway
                 ? { source: 'telegram', channelId: reportChatId }
@@ -1888,49 +1915,32 @@ async function runAgentLoop(config, options = {}) {
             const fullReportHours = parseReportHours(process.env.MAMA_TRIGGER_LOOP_FULL_REPORT_HOURS || '');
             // Constructed whenever the report SINK exists, even with no scheduled
             // hours (empty hours -> shouldFire never fires): on-demand reports
-            // (report_request) need the persistent anchor state to load and advance
-            // the delta window regardless of the scheduled leg (review PR#153).
+            // API-triggered reports need the persistent anchor state regardless of
+            // whether scheduled hours are configured.
             const reportScheduler = reportDelivery
                 ? new ReportScheduler(fullReportHours, new FileReportScheduleStore((0, config_manager_js_1.expandPath)('~/.mama/operator/report-schedule-state.json')))
                 : undefined;
-            const triggerAgentRuntime = createTriggerAgentRuntime(runtimeBackend, {
-                model: config.agent.model,
-                cwd: workspaceRoot,
-                command: runtimeBackend === 'cline'
-                    ? (process.env.MAMA_CLINE_COMMAND ?? config.agent.cline_command)
-                    : process.env.MAMA_CODEX_COMMAND,
-                provider: config.agent.cline_provider,
-                dataDir: config.agent.cline_data_dir,
-                effort: config.agent.effort,
-            });
-            stopTriggerAgentRuntime = () => triggerAgentRuntime.stop();
             const ownerEventEnvelopeAuthority = envelopeBootstrap.envelopeAuthority;
             const ownerEventExecution = (0, owner_event_policy_js_1.resolveOwnerEventExecution)({
                 issuance: envelopeBootstrap.metadata.issuance,
                 hasAuthority: ownerEventEnvelopeAuthority !== undefined,
             });
-            // Scope-independent packet readers, shared by the report leg and the event turn.
-            const reportContextDeps = {
-                readOperationalIssues: () => (0, operational_issues_js_1.listOpenOperationalIssues)(issueDb, 20, 'warn').map((issue) => ({
-                    issueId: issue.issueId,
-                    surface: issue.surface,
-                    severity: issue.severity,
-                    summary: `${issue.signature}: ${issue.lastError ?? ''}`.slice(0, 300),
-                    occurrences: issue.occurrences,
-                    firstSeenAt: new Date(issue.firstSeenAt).toISOString(),
-                })),
-                listTaskPage: (input) => taskLedger.listPage(input),
-                readClaims: (scope) => mamaCore.queryRelevantTruth({ query: '', scopes: scope.memoryScopes }),
-                readTrello: async (scope) => {
-                    if (!scope.rawConnectors.includes('trello')) {
-                        throw new Error('Trello is outside the owner-report read scope');
-                    }
-                    return (0, query_tools_js_1.getTrelloKanban)({ maxCardsPerList: 100 });
-                },
-                buildProvenanceLookup: provenance_lookup_js_1.buildProvenanceLookup,
-                correlate: external_correlation_js_1.correlateTasksWithExternalItems,
-                readChanges: (_scope, input, nowMs) => (0, changes_projection_js_1.readChanges)(taskLedger, input, nowMs),
-                now: Date.now,
+            const ownerMaintenanceAsk = async (prompt) => {
+                const result = await agentLoop.run(prompt, {
+                    sessionKey: owner_runtime_js_1.OWNER_RUNTIME_SESSION_KEY,
+                    source: 'operator',
+                    channelId: 'trigger-maintenance',
+                    agentContext: backgroundOwnerContext,
+                    sessionPolicyRole: ownerRole,
+                    prepareEnvelope: async () => {
+                        const envelope = await issueOwnerRuntimeEnvelope('trigger-maintenance', 600);
+                        if (!envelope)
+                            throw new Error('Owner maintenance requires envelope authority');
+                        return envelope;
+                    },
+                    requestTimeoutMs: 600_000,
+                });
+                return result.response;
             };
             const triggerLoop = new OperatorTriggerLoop({
                 backend: runtimeBackend,
@@ -1938,31 +1948,32 @@ async function runAgentLoop(config, options = {}) {
                 memory: createMamaMemoryPort(),
                 registry: triggerRegistry,
                 ...(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.
-                // JSON tasks (authoring/review) use a provider-specific, tool-free runtime.
-                // Full reports run in one fresh, tool-free persona turn. Current state is compiled and
-                // persisted by the host before this call; digest composition remains on the same persona.
+                askAgent: ownerMaintenanceAsk,
+                // TG-03/TG-04/TG-05: a report is another stimulus for the standing
+                // owner subject. It keeps the same backend thread and progressive tool
+                // catalog while the current envelope narrows effects for this delivery.
                 reportAsk: createPersonaReportAsk({
                     run: async (prompt, sourceMessageRef) => {
-                        const reportAgentPolicy = buildOperatorReportAgentPolicy(config.agent.model, runtimeBackend, privateConnectorPolicy);
+                        const reportAgentPolicy = buildOperatorReportAgentPolicy(config.agent.model, runtimeBackend, privateConnectorPolicy, ownerRole);
                         const result = await agentLoop.runWithContent([{ type: 'text', text: prompt }], {
-                            sessionKey: report_run_js_1.OPERATOR_REPORT_SESSION_KEY,
+                            sessionKey: owner_runtime_js_1.OWNER_RUNTIME_SESSION_KEY,
                             source: 'operator',
                             channelId: 'report',
-                            // Without a role the Code-Act branch strips the gateway catalog and
-                            // injects nothing back, so the report agent gets ZERO tools and cannot
-                            // gather no matter what the prompt instructs (roleAllowsOuterCodeAct
-                            // fails closed on an absent role - agent-loop.ts). Same built-in
-                            // least-privilege treatment the Stage-2 workers get.
+                            // The current report role narrows effect authority; the stable
+                            // sessionPolicyRole keeps the owner thread compatible.
                             agentContext: reportAgentPolicy.agentContext,
+                            sessionPolicyRole: ownerRole,
                             gatewayToolsPrompt: reportAgentPolicy.gatewayToolsPrompt,
-                            // Stateless report lane: each run starts on a fresh session so the
-                            // continuous session no longer accumulates every run's gather dumps
-                            // (measured 146s -> 521s growth over 3 days). Continuity comes from
-                            // the storage layer (self-gather + mama_recall + report store).
-                            freshSession: true,
+                            prepareEnvelope: async () => {
+                                const envelope = await issueOwnerRuntimeEnvelope('report', 600);
+                                if (!envelope)
+                                    throw new Error('Owner report requires envelope authority');
+                                return envelope;
+                            },
+                            requestTimeoutMs: 600_000,
+                            ownerJournalPrompt: sourceMessageRef
+                                ? `Report stimulus: ${sourceMessageRef}`
+                                : prompt,
                             ...(sourceMessageRef ? { sourceMessageRef } : {}),
                         });
                         return {
@@ -1976,28 +1987,28 @@ async function runAgentLoop(config, options = {}) {
                             ...(result.modelRunProvenance === undefined
                                 ? {}
                                 : { modelRunProvenance: result.modelRunProvenance }),
+                            ...(result.ownerJournalProvenance === undefined
+                                ? {}
+                                : { ownerJournalProvenance: result.ownerJournalProvenance }),
                         };
                     },
                     log: (line) => console.log(line),
                     onRunProvenance: (provenance) => {
                         lastReportProvenance = provenance;
                     },
+                    onRecoveryFailure: () => {
+                        recordIssue({
+                            surface: 'delivery',
+                            signature: 'journal_commit_failed',
+                            severity: 'error',
+                            error: 'Report completed but owner runtime recovery journal did not persist',
+                        });
+                    },
                 }),
-                review: (trigger, context) => reviewTriggerCLI(trigger, context, triggerAgentRuntime.askReview),
+                review: (trigger, context) => reviewTriggerCLI(trigger, context, ownerMaintenanceAsk),
                 reportDelivery,
                 reportTarget,
                 reportScheduler,
-                fullReportReadScope: (() => {
-                    const projectId = (0, reactive_config_js_1.resolveReactiveProjectRoot)(config, process.env);
-                    return {
-                        projectRefs: [{ kind: 'project', id: projectId }],
-                        memoryScopes: uniqueMemoryScopes((0, scope_context_js_1.deriveMemoryScopes)({ source: 'operator', channelId: 'report', projectId })),
-                        rawConnectors: [
-                            ...privateConnectorPolicy.projectRawConnectors('operator-report', codeActRawConnectors),
-                        ],
-                    };
-                })(),
-                compileFullReportContext: async ({ readScope, windowEvidence, since }) => (0, report_context_js_1.compileOwnerReportContext)({ readScope, windowEvidence, since }, reportContextDeps),
                 // TG-06: composition supplies provenance immediately to the prepared
                 // delivery; this callback receives that durable artifact only after send success.
                 fullReportProvenance: () => lastReportProvenance,
@@ -2038,14 +2049,11 @@ async function runAgentLoop(config, options = {}) {
             }
             const stopTriggerLoop = triggerLoop.start();
             stopOwnerEventRuntime = async () => {
-                await Promise.all([stopTriggerLoop(), triggerAgentRuntime.stop()]);
+                await stopTriggerLoop();
             };
             // M2.4: point the connector sink's forwarder at this loop now that it exists.
             triggerLoopNudge.current = () => triggerLoop.nudge();
             triggerLoopFullReport.current = () => triggerLoop.startFullReport();
-            // S1-T3: owner-intent forwarder - report_request routes to the SAME
-            // report machinery (fresh session, delta anchor, consume semantics).
-            toolExecutor.setReportRequestHandler(() => triggerLoop.startFullReport());
             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
@@ -2099,17 +2107,11 @@ async function runAgentLoop(config, options = {}) {
                     inbox: ownerEventInbox,
                     runner: agentLoop,
                     agentContext: ownerEventContext,
-                    compilePacket: async (batch) => (0, report_context_js_1.serializeOwnerReportContext)(await (0, report_context_js_1.compileChannelPacket)({
-                        readScope: ownerEventReadScope(batch),
-                        channelKey: batch.channelKey,
-                        eventIds: batch.eventIds,
-                        since: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString(),
-                    }, reportContextDeps)),
-                    buildPrompt: async (batch, packet) => {
+                    ownerRuntimeRole: ownerRole,
+                    buildPrompt: async (batch) => {
                         const readScope = ownerEventReadScope(batch);
                         return (0, owner_event_prompt_js_1.buildOwnerEventPrompt)({
                             batch,
-                            packet,
                             learning: await buildLearningBlockFor('event', readScope.memoryScopes, batch.lines.join('\n').slice(0, 500)),
                             ownerBrief: (0, console_brief_js_1.projectConsoleBriefForPrompt)((0, console_brief_js_1.loadConsoleBrief)(), privateConnectorPolicy),
                             skillContent: await ownerEventPromptEnhancer.detectSkillMatch(batch.lines.join('\n')),
@@ -2166,7 +2168,7 @@ async function runAgentLoop(config, options = {}) {
                     // operator DB closes.
                     if (ownerEventTickPromise)
                         await ownerEventTickPromise;
-                    await Promise.all([stopTriggerLoop(), triggerAgentRuntime.stop()]);
+                    await stopTriggerLoop();
                 };
             }
             else {
@@ -2180,7 +2182,6 @@ async function runAgentLoop(config, options = {}) {
         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);
         }
     }
@@ -2193,13 +2194,13 @@ async function runAgentLoop(config, options = {}) {
         healthCheckService,
         rawStore: rawStoreForApi,
         enabledConnectors: enabledConnectorNames,
-        agentLoop,
         getAdapter,
         envelopeMetadata: envelopeBootstrap.metadata,
         envelopeAuthority: envelopeBootstrap.envelopeAuthority,
         contextCompileService,
         connectorConfigLoadResult,
         privateConnectorPolicy,
+        runOwnerStimulus,
     });
     const apiRoutesHandle = await (0, api_routes_init_js_1.registerApiRoutes)({
         config,
@@ -2209,7 +2210,6 @@ async function runAgentLoop(config, options = {}) {
         mamaApi,
         messageRouter,
         reportContextStore,
-        agentLoop,
         toolExecutor,
         discordGateway,
         slackGateway,
@@ -2251,7 +2251,6 @@ async function runAgentLoop(config, options = {}) {
         gateways,
         pluginLoader,
         agentLoop,
-        memoryAgentLoop,
         stopExtraction,
         sessionStore,
         db,