@jungjaehoon/mama-os 0.20.1 → 0.22.0

package/dist/cli/runtime/api-routes-init.js

@@ -53,6 +53,7 @@ const session_service_js_1 = require("../../validation/session-service.js");
 const agent_store_js_1 = require("../../db/agent-store.js");
 const memory_agent_dashboard_js_1 = require("../../memory/memory-agent-dashboard.js");
 const upload_handler_js_1 = require("../../api/upload-handler.js");
+const operator_tasks_handler_js_1 = require("../../api/operator-tasks-handler.js");
 const auth_middleware_js_1 = require("../../api/auth-middleware.js");
 const utilities_js_1 = require("./utilities.js");
 const debugLogger = __importStar(require("@jungjaehoon/mama-core/debug-logger"));
@@ -200,46 +201,46 @@ async function registerApiRoutes(params) {
     }
     // Wire EventBus to tool executor for agent_notices tool
     toolExecutor.setAgentEventBus(eventBus);
-    // ── Report Slots ──────────────────────────────────────────────────────
-    {
-        const { broadcastReportUpdate } = await import('../../api/report-handler.js');
-        // Manual refresh endpoint (kept for compatibility)
-        apiServer.app.post('/api/report/refresh', auth_middleware_js_1.requireAuth, (_req, res) => {
-            res.json({ ok: true, message: 'Viewer now renders data directly from Intelligence API' });
-        });
-        // Wire report_publish tool to OS agent — only briefing slot
-        toolExecutor.setReportPublisher((slots) => {
-            for (const [slotId, html] of Object.entries(slots)) {
-                if (slotId !== 'briefing')
-                    continue; // only accept briefing slot
-                apiServer.reportStore.update(slotId, html, 0);
-            }
-            broadcastReportUpdate(apiServer.reportSseClients, {
-                slots: apiServer.reportStore.getAllSorted(),
-            });
-            routesLogger.debug(`[Report] Agent published briefing slot`);
-            eventBus.emit({
-                type: 'agent:action',
-                agent: 'dashboard-agent',
-                action: 'publish',
-                target: 'briefing',
-            });
-        });
-        // ── Conductor Persona (section injection — non-destructive) ────────
-        const { ensureConductorPersona } = await import('../../multi-agent/conductor-persona.js');
-        ensureConductorPersona();
-        // ── Dashboard Agent ─────────────────────────────────────────────────
-        const { ensureDashboardPersona } = await import('../../multi-agent/dashboard-agent-persona.js');
-        ensureDashboardPersona();
-        routesLogger.debug('[Dashboard Agent] Persona ensured at ~/.mama/personas/dashboard.md');
-        // Merge code-act MCP server into mama-mcp-config.json
-        // Makes code_act available to all CLI processes (AgentProcessManager agents)
+    (0, operator_tasks_handler_js_1.registerOperatorTaskRoutes)(apiServer.app, {
+        getTaskLedger: () => toolExecutor.getTaskLedger(),
+    });
+    const hasEnabledAgentConfig = (agentId) => {
+        const agentConfig = config.multi_agent?.agents?.[agentId];
+        return Boolean(agentConfig && agentConfig.enabled !== false);
+    };
+    // ── Report Slots + legacy dashboard/wiki fanout ───────────────────────
+    const dashboardAgentConfigured = hasEnabledAgentConfig('dashboard-agent');
+    const wikiAgentConfigured = hasEnabledAgentConfig('wiki-agent');
+    // Manual refresh endpoint (kept for compatibility)
+    apiServer.app.post('/api/report/refresh', auth_middleware_js_1.requireAuth, (_req, res) => {
+        res.json({ ok: true, message: 'Viewer now renders data directly from Intelligence API' });
+    });
+    // ── Conductor Persona (section injection — non-destructive) ────────
+    const { ensureConductorPersona } = await import('../../multi-agent/conductor-persona.js');
+    ensureConductorPersona();
+    if (dashboardAgentConfigured || wikiAgentConfigured) {
+        // Merge code-act MCP server into mama-mcp-config.json.
+        // Makes code_act available to configured legacy self-paced agents.
         const codeActServerPath = node_path_1.default.join(__dirname, '../../mcp/code-act-server.js');
         try {
             const mamaMcpConfigPath = node_path_1.default.join((0, node_os_1.homedir)(), '.mama', 'mama-mcp-config.json');
-            const existing = (0, node_fs_1.existsSync)(mamaMcpConfigPath)
-                ? JSON.parse((0, node_fs_1.readFileSync)(mamaMcpConfigPath, 'utf-8'))
-                : { mcpServers: {} };
+            let existing = { mcpServers: {} };
+            if ((0, node_fs_1.existsSync)(mamaMcpConfigPath)) {
+                try {
+                    const parsedConfig = JSON.parse((0, node_fs_1.readFileSync)(mamaMcpConfigPath, 'utf-8'));
+                    if (parsedConfig && typeof parsedConfig === 'object' && !Array.isArray(parsedConfig)) {
+                        existing = parsedConfig;
+                    }
+                }
+                catch (parseErr) {
+                    routesLogger.warn('[api-routes-init] Invalid MCP config JSON; recreating code-act entry:', parseErr);
+                }
+            }
+            if (!existing.mcpServers ||
+                typeof existing.mcpServers !== 'object' ||
+                Array.isArray(existing.mcpServers)) {
+                existing.mcpServers = {};
+            }
             existing.mcpServers['code-act'] = {
                 command: 'node',
                 args: [codeActServerPath],
@@ -251,8 +252,23 @@ async function registerApiRoutes(params) {
         catch (err) {
             routesLogger.warn('[api-routes-init] Failed to merge code-act into MCP config:', err);
         }
+    }
+    // report_publish is a core surface (feeds the /ui operator board), not a
+    // multi-agent feature: wire it unconditionally. All slot ids are accepted;
+    // size/count caps and loud logging live in createReportPublisher.
+    {
+        const { createReportPublisher } = await import('../../api/report-handler.js');
+        toolExecutor.setReportPublisher(createReportPublisher(apiServer.reportStore, apiServer.reportSseClients));
+    }
+    if (dashboardAgentConfigured) {
+        // ── Dashboard Agent ───────────────────────────────────────────────
+        const { ensureDashboardPersona } = await import('../../multi-agent/dashboard-agent-persona.js');
+        ensureDashboardPersona();
+        routesLogger.debug('[Dashboard Agent] Persona ensured at ~/.mama/personas/dashboard.md');
         // Dashboard cron: 30-min interval via AgentProcessManager
-        const dashboardPrompt = `You are triggered on a schedule. Before writing anything, determine if an update is needed:
+        // Built PER RUN: the tracker's D-day arithmetic needs today's date, and a
+        // module-const prompt would freeze it (#134 lesson).
+        const buildDashboardPrompt = () => `You are triggered on a schedule. Today is ${new Date().toISOString().slice(0, 10)}. Before writing anything, determine if an update is needed:
 
 1. Use agent_notices({limit: 50}) to find the most recent dashboard-agent publish/task_complete notice. Treat that as the last briefing boundary.
 2. Use context_compile first to find recent substantive decisions (limit 20, max_tool_calls 2, strictness "balanced").
@@ -260,279 +276,507 @@ async function registerApiRoutes(params) {
    Do not include dashboard_briefing, wiki_compilation, system-audit, or audit-log labels in the context_compile task text; filter those operational summaries after the packet returns.
    If context_compile is unavailable because there is no active worker envelope, fall back to mama_search once (limit 20).
 3. If NO substantive decisions or agent alerts exist since the last dashboard publish → respond "NO_UPDATE" and stop. Do NOT call report_publish.
-4. If new substantive information exists → analyze it, write a new briefing, and publish via report_publish in the "briefing" slot.
+4. If new substantive information exists -> analyze it and publish ALL FOUR board slots (briefing, action_required, decisions, pipeline) in a SINGLE report_publish call, using the board HTML vocabulary from your persona. The pipeline slot is the item tracker projected from task_list (see your persona); compute D-day from today's date above.
 5. Do NOT call mama_save for the briefing; report_publish and agent_activity are the durable operational record.
 
 This saves resources. Only publish when there is genuinely new information to report.`;
-        const runDashboardAgent = async () => {
+        // Owner-initiated refresh skips the NO_UPDATE delta gate: an explicit
+        // request means "rebuild the board now", not "tell me nothing changed".
+        const buildForcedDashboardPrompt = () => buildDashboardPrompt().replace(/3\. If NO substantive decisions[^\n]*\n/, '3. The owner explicitly requested a fresh board: do NOT reply NO_UPDATE. Rebuild and publish even if nothing changed since the last publish.\n');
+        const doDashboardRun = async (opts) => {
             const pm = toolExecutor.getAgentProcessManager();
             if (!pm) {
                 routesLogger.warn('[Dashboard Agent] AgentProcessManager not available yet');
                 return;
             }
             try {
-                routesLogger.debug('[Dashboard Agent] Checking for updates...');
-                const { noUpdate } = await executeValidatedRun('dashboard-agent', dashboardPrompt);
-                if (noUpdate) {
-                    routesLogger.debug('[Dashboard Agent] No changes detected, skipped');
-                }
-                else {
-                    routesLogger.debug('[Dashboard Agent] Briefing published');
-                }
+                // console.log on run outcomes: the DebugLogger only surfaces warn/error in the
+                // daemon log, and a silent outcome reads as a hang from the outside.
+                console.log(`[Dashboard Agent] run started${opts?.force ? ' (owner-forced, delta gate bypassed)' : ''}`);
+                const { noUpdate } = await executeValidatedRun('dashboard-agent', opts?.force ? buildForcedDashboardPrompt() : buildDashboardPrompt());
+                console.log(noUpdate
+                    ? '[Dashboard Agent] no changes detected, publish skipped'
+                    : '[Dashboard Agent] board published');
             }
             catch (err) {
                 routesLogger.error('[Dashboard Agent] Error:', err instanceof Error ? err.message : err);
             }
         };
+        // ONE board-writer queue: dashboard cron, manual refresh, AND reconcile runs
+        // all serialize here -- the shared agent process rejects concurrent requests
+        // ('Process is busy' class). Per-job rejection propagates to the caller
+        // while the chain itself survives (M8 review: a caller must be able to
+        // distinguish its own job's failure).
+        let boardWriterChain = Promise.resolve();
+        const boardWriterQueue = {
+            push(job) {
+                const jobPromise = boardWriterChain.then(job);
+                boardWriterChain = jobPromise.catch(() => { });
+                return jobPromise;
+            },
+        };
+        const runDashboardAgent = (opts) => boardWriterQueue.push(() => doDashboardRun(opts)).catch(() => { });
         // First run after 10s (let connectors poll first), then every 30 min
         setTimeout(runDashboardAgent, 10_000);
         setInterval(runDashboardAgent, 30 * 60 * 1000);
-        // Manual trigger
+        // Manual trigger (owner-forced: bypasses the delta gate)
         apiServer.app.post('/api/report/agent-refresh', auth_middleware_js_1.requireAuth, async (_req, res) => {
-            runDashboardAgent().catch(() => { });
-            res.json({ ok: true, message: 'Dashboard agent triggered' });
+            runDashboardAgent({ force: true }).catch(() => { });
+            res.json({ ok: true, message: 'Dashboard agent triggered (forced refresh)' });
         });
-        // ── Wiki Agent ──────────────────────────────────────────────────────
-        const wikiConfig = config.wiki;
-        if (wikiConfig?.enabled && wikiConfig.vaultPath) {
-            const { ensureWikiPersona } = await import('../../multi-agent/wiki-agent-persona.js');
-            const { ObsidianWriter } = await import('../../wiki/obsidian-writer.js');
-            ensureWikiPersona();
-            const obsWriter = new ObsidianWriter(wikiConfig.vaultPath, wikiConfig.wikiDir || 'wiki');
-            obsWriter.ensureDirectories();
-            routesLogger.debug(`[Wiki Agent] Persona ensured, vault: ${obsWriter.getWikiPath()}`);
-            // Wire Obsidian vault path for CLI tool
-            const fullWikiPath = obsWriter.getWikiPath();
-            toolExecutor.setObsidianVaultPath(fullWikiPath);
-            routesLogger.debug(`[Wiki Agent] Obsidian CLI vault: ${fullWikiPath}`);
-            // Ensure Obsidian is running for CLI access (macOS only)
+        // -- M8 board reconcile leg (freshness layer; default OFF, opt-in like
+        // MAMA_TRIGGER_LOOP). The trigger loop emits operator:channel-delta after
+        // committing its cursor; the 30-min cron above remains the repair pass.
+        if (process.env.MAMA_BOARD_RECONCILE === '1') {
+            const { buildReconcilePrompt, ReconcileScheduler } = await import('../../operator/board-reconcile.js');
+            const { captureSnapshot, verifyAfterRun, OBLIGATED_TOOLS } = await import('../../operator/action-verifier.js');
+            const kagemushaContext = (process.env.MAMA_RECONCILE_TASK_CONTEXT ?? 'native') === 'kagemusha';
+            // Verifier deps (M8 Phase 2): run-bound signals only -- trace rows from
+            // the dashboard agent's gateway_tool_call activity, notes from the
+            // operator ledger. Observe, never block.
+            const reconcileLedger = toolExecutor.getTaskLedger();
+            // gateway_tool_call rows now populate normalized_tool_name at the logging
+            // site; the input_summary fallback covers rows written before that fix.
+            const traceToolList = OBLIGATED_TOOLS.map((t) => `'${t}'`).join(',');
+            const verifierDeps = {
+                getSlots: () => apiServer.reportStore.getAllSorted(),
+                getLedgerHash: () => reconcileLedger?.payloadHash() ?? '',
+                getScopedNoteMaxId: (scope) => reconcileLedger?.maxNoUpdateId(scope) ?? 0,
+                getTraceMaxId: () => {
+                    if (!sessionsDb)
+                        return 0;
+                    const row = sessionsDb
+                        .prepare(`SELECT MAX(id) AS max_id FROM agent_activity
+               WHERE type = 'gateway_tool_call' AND agent_id = 'dashboard-agent'`)
+                        .get();
+                    return row.max_id ?? 0;
+                },
+                countObligatedTraceRowsSince: (maxId) => {
+                    if (!sessionsDb)
+                        return 0;
+                    const row = sessionsDb
+                        .prepare(`SELECT COUNT(*) AS n FROM agent_activity
+               WHERE type = 'gateway_tool_call' AND agent_id = 'dashboard-agent'
+                 AND id > ? AND (normalized_tool_name IN (${traceToolList}) OR input_summary IN (${traceToolList}))`)
+                        .get(maxId);
+                    return row.n;
+                },
+            };
+            const reconcileScheduler = new ReconcileScheduler({
+                debounceMs: Number(process.env.MAMA_RECONCILE_DEBOUNCE_MS) || undefined,
+                maxWaitMs: Number(process.env.MAMA_RECONCILE_MAX_WAIT_MS) || undefined,
+                globalMaxPerHour: Number(process.env.MAMA_RECONCILE_MAX_PER_HOUR) || undefined,
+                log: (line) => console.log(line),
+                run: (channelKey, deltaLines) => boardWriterQueue.push(async () => {
+                    const scope = `reconcile:${channelKey}`;
+                    const before = captureSnapshot(verifierDeps, scope);
+                    const prompt = buildReconcilePrompt({
+                        channelKey,
+                        deltaLines,
+                        todayIso: new Date().toISOString().slice(0, 10),
+                        kagemushaContext,
+                    });
+                    await executeValidatedRun('dashboard-agent', prompt, {
+                        requestTimeout: 300_000,
+                    });
+                    const verdict = verifyAfterRun(verifierDeps, before, scope);
+                    const outcome = verdict.verified ? 'reconcile_verified' : 'reconcile_unverified';
+                    console.log(`[reconcile] ${outcome} channel=${channelKey}${verdict.effects.length > 0 ? ` (${verdict.effects.join('; ')})` : ''}`);
+                    try {
+                        if (sessionsDb) {
+                            (0, agent_store_js_1.logActivity)(sessionsDb, {
+                                agent_id: 'dashboard-agent',
+                                agent_version: 0,
+                                type: outcome,
+                                input_summary: `reconcile ${channelKey}`,
+                                output_summary: verdict.effects.join('; '),
+                                execution_status: 'completed',
+                                trigger_reason: 'reconcile',
+                            });
+                        }
+                    }
+                    catch {
+                        /* telemetry only */
+                    }
+                    if (!verdict.verified) {
+                        // Loud, never blocking (observability over restriction).
+                        eventBus.emit({
+                            type: 'agent:action',
+                            agent: 'Dashboard Agent',
+                            action: 'reconcile_unverified',
+                            target: channelKey,
+                        });
+                    }
+                }),
+            });
+            eventBus.on('operator:channel-delta', (event) => {
+                if (event.type === 'operator:channel-delta') {
+                    reconcileScheduler.enqueue(event.channelKey, event.lines);
+                }
+            });
+            // Manual reconcile: lines from the body, or the caller must supply them
+            // (no silent alternate data path -- M8 review #17).
+            apiServer.app.post('/api/operator/reconcile', auth_middleware_js_1.requireAuth, (req, res) => {
+                const { channelKey, lines } = (req.body ?? {});
+                if (!channelKey || !Array.isArray(lines) || lines.length === 0) {
+                    res.status(400).json({
+                        ok: false,
+                        error: 'channelKey and non-empty lines[] are required',
+                    });
+                    return;
+                }
+                reconcileScheduler.enqueue(channelKey, lines);
+                res.json({ ok: true, message: 'Reconcile queued (async; runs after debounce)' });
+            });
+            console.log('[reconcile] Board reconcile leg enabled (MAMA_BOARD_RECONCILE=1)');
+        }
+    }
+    else {
+        routesLogger.debug('[Dashboard Agent] Skipped; dashboard-agent is not configured');
+    }
+    // ── Wiki Agent ──────────────────────────────────────────────────────
+    const wikiConfig = config.wiki;
+    if (wikiAgentConfigured && wikiConfig?.enabled && wikiConfig.vaultPath) {
+        const { ensureWikiPersona } = await import('../../multi-agent/wiki-agent-persona.js');
+        const { ObsidianWriter } = await import('../../wiki/obsidian-writer.js');
+        ensureWikiPersona();
+        const obsWriter = new ObsidianWriter(wikiConfig.vaultPath, wikiConfig.wikiDir || 'wiki');
+        obsWriter.ensureDirectories();
+        routesLogger.debug(`[Wiki Agent] Persona ensured, vault: ${obsWriter.getWikiPath()}`);
+        // Wire Obsidian vault path for CLI tool. The wiki directory itself is what
+        // gets registered as an Obsidian vault (agent-facing paths like daily/... are
+        // relative to it), so the CLI vault name is the wiki path's basename.
+        const fullWikiPath = obsWriter.getWikiPath();
+        const obsidianVaultName = node_path_1.default.basename(fullWikiPath);
+        toolExecutor.setObsidianVaultPath(fullWikiPath, obsidianVaultName);
+        routesLogger.debug(`[Wiki Agent] Obsidian CLI vault: ${fullWikiPath} (vault=${obsidianVaultName})`);
+        // Ensure Obsidian is running with the wiki vault open (macOS only).
+        // NOTE: obsidian://open?vault= only opens vaults ALREADY registered in
+        // Obsidian; registering the wiki directory as a vault is a one-time manual
+        // setup step. If it is not registered, the CLI reports unavailable and the
+        // agent falls back to wiki_publish (direct file writes still work).
+        if (process.platform === 'darwin') {
             try {
-                const { execSync: execSyncChild } = await import('child_process');
-                execSyncChild('pgrep -x Obsidian || open -a Obsidian', {
-                    timeout: 5000,
-                    stdio: 'ignore',
+                const { execFile: execFileChild } = await import('child_process');
+                execFileChild('open', [`obsidian://open?vault=${encodeURIComponent(obsidianVaultName)}`], { timeout: 5000 }, () => {
+                    /* non-fatal: CLI will return error, agent falls back to wiki_publish */
                 });
             }
             catch {
-                /* non-fatal: CLI will return error, agent falls back to wiki_publish */
+                /* non-fatal */
             }
-            // Wire wiki_publish tool to shared gateway executor (used by code-act path)
-            toolExecutor.setWikiPublisher((pages) => {
-                for (const page of pages) {
-                    obsWriter.writePage(page);
-                }
-                if (pages.length > 0) {
-                    obsWriter.updateIndex(pages);
-                    obsWriter.appendLog('compile', `Published ${pages.length} pages`);
-                }
-                routesLogger.debug(`[Wiki Agent] Published ${pages.length} pages to vault`);
-                eventBus.emit({
-                    type: 'wiki:compiled',
-                    pages: pages.map((p) => p.path || ''),
-                });
+        }
+        // Wire wiki_publish tool to shared gateway executor (used by code-act path)
+        toolExecutor.setWikiPublisher((pages) => {
+            for (const page of pages) {
+                obsWriter.writePage(page);
+            }
+            if (pages.length > 0) {
+                obsWriter.updateIndex(pages);
+                obsWriter.appendLog('compile', `Published ${pages.length} pages`);
+            }
+            routesLogger.debug(`[Wiki Agent] Published ${pages.length} pages to vault`);
+            eventBus.emit({
+                type: 'wiki:compiled',
+                pages: pages.map((p) => p.path || ''),
             });
-            // Wiki trigger via executeValidatedRun
-            const runWikiAgent = async () => {
-                if (!toolExecutor.getAgentProcessManager()) {
-                    routesLogger.warn('[Wiki Agent] AgentProcessManager not available yet');
-                    return;
-                }
-                try {
-                    routesLogger.debug('[Wiki Agent] Checking for updates...');
-                    const wikiPrompt = `You are triggered on a schedule. Before writing anything, determine if an update is needed:
+        });
+        // Wiki trigger via executeValidatedRun
+        const doWikiRun = async () => {
+            if (!toolExecutor.getAgentProcessManager()) {
+                routesLogger.warn('[Wiki Agent] AgentProcessManager not available yet');
+                return;
+            }
+            try {
+                routesLogger.debug('[Wiki Agent] Checking for updates...');
+                const wikiPrompt = `You are triggered on a schedule. Before writing anything, determine if an update is needed:
 
 1. Use agent_notices({limit: 100}) to find the most recent wiki-agent compiled/publish/task_complete notice. Treat that as the last compilation boundary.
-2. Use context_compile first to find recent substantive decisions (limit 30, max_tool_calls 3, strictness "balanced").
+2. NOVELTY CHECK by recency, not semantics: call mama_search({limit: 30}) with NO query -- that returns the newest decisions in creation order regardless of language or wording (semantic/lexical search misses cross-language items, which caused missed compilations). Compare created_at against the boundary.
+3. If NO substantive decisions are newer than the boundary -> respond "NO_UPDATE" and stop. Do NOT call obsidian or wiki_publish.
+4. If new items exist, use context_compile first to gather supporting context (limit 30, max_tool_calls 3, strictness "balanced").
    Use this exact task text for context_compile: "recent substantive project decisions, task progress, agent alerts, and major changes".
    Do not include dashboard_briefing, wiki_compilation, system-audit, or audit-log labels in the context_compile task text; filter those operational summaries after the packet returns.
-   If context_compile is unavailable because there is no active worker envelope, fall back to mama_search once (limit 30).
-3. If NO substantive decisions exist since the last wiki compilation → respond "NO_UPDATE" and stop. Do NOT call obsidian or wiki_publish.
-4. If new substantive decisions exist → use obsidian("search") to check existing pages, then update or create pages as needed. Clean up duplicates.
-5. Do NOT call mama_save for the compilation; Obsidian/wiki files plus agent_activity are the durable operational record.
+   If the packet misses some of the new items from step 2 (it often will for cross-language content), write from the step-2 items directly -- the recency list is authoritative for WHAT is new; the packet only enriches.
+   If context_compile is unavailable because there is no active worker envelope, fall back to ONE queried mama_search for enrichment and continue from the step-2 recency list.
+5. Then follow your persona: APPEND today's daily note (daily/YYYY-MM-DD.md, create with the section skeleton on first write of the day), then promote qualifying lesson candidates into lessons/ pages (search before create; update, never duplicate). Do NOT write per-task status pages.
+6. Do NOT call mama_save for the compilation; Obsidian/wiki files plus agent_activity are the durable operational record.
 
 This saves resources. Only compile when there is genuinely new information to document.`;
-                    const { noUpdate } = await executeValidatedRun('wiki-agent', wikiPrompt, {
-                        requestTimeout: 600_000,
+                const { noUpdate } = await executeValidatedRun('wiki-agent', wikiPrompt, {
+                    requestTimeout: 600_000,
+                });
+                if (noUpdate) {
+                    routesLogger.debug('[Wiki Agent] No changes detected, skipped');
+                }
+                else {
+                    routesLogger.debug('[Wiki Agent] Compilation complete');
+                }
+            }
+            catch (err) {
+                routesLogger.error('[Wiki Agent] Error:', err instanceof Error ? err.message : err);
+            }
+        };
+        // Serialize ALL wiki runs (boot, event-driven, manual) on one chain -- the
+        // shared agent process rejects concurrent requests, so the boot run and a
+        // manual trigger raced into 'Process is busy' (same pattern as the
+        // dashboard agent's runDashboardAgent chain above).
+        let wikiRunChain = Promise.resolve();
+        const runWikiAgent = () => {
+            wikiRunChain = wikiRunChain.then(doWikiRun).catch(() => { });
+            return wikiRunChain;
+        };
+        // Event-driven: compile when extraction completes. Trailing-edge debounce so
+        // bursts of extraction:completed events coalesce into one wiki compile run.
+        eventBus.onDebounced('extraction:completed', () => runWikiAgent(), 30_000);
+        // Promotion feeds the wiki: freshly promoted decisions are exactly the
+        // material daily notes and lessons compile from.
+        eventBus.onDebounced('memory:promoted', () => runWikiAgent(), 30_000);
+        // Emit agent:action notices when wiki pages are compiled
+        eventBus.on('wiki:compiled', (event) => {
+            if (event.type === 'wiki:compiled') {
+                for (const page of event.pages) {
+                    eventBus.emit({
+                        type: 'agent:action',
+                        agent: 'Wiki Agent',
+                        action: 'compiled',
+                        target: page,
                     });
-                    if (noUpdate) {
-                        routesLogger.debug('[Wiki Agent] No changes detected, skipped');
-                    }
-                    else {
-                        routesLogger.debug('[Wiki Agent] Compilation complete');
-                    }
                 }
-                catch (err) {
-                    routesLogger.error('[Wiki Agent] Error:', err instanceof Error ? err.message : err);
+            }
+        });
+        // Manual trigger API
+        apiServer.app.post('/api/wiki/compile', auth_middleware_js_1.requireAuth, async (_req, res) => {
+            runWikiAgent().catch(() => { });
+            res.json({ ok: true, message: 'Wiki compilation triggered' });
+        });
+        // First run after 15s (let connectors and dashboard agent go first)
+        setTimeout(runWikiAgent, 15_000);
+        routesLogger.info('[Wiki Agent] Ready — triggers: extraction:completed event, POST /api/wiki/compile');
+    }
+    // -- Memory Promotion: scheduled observation->decision curation --
+    // Owner directive 2026-07-11: the decision layer starved after the 07-03/04
+    // backfill because nothing periodically judges connector-ingested business
+    // data (the M0 kill switch removed direct LLM extraction, and the memory
+    // agent only audits owner conversation turns). This pass has the memory
+    // agent promote DURABLE judgments only -- task states stay on the board.
+    const memoryAgentConfigured = hasEnabledAgentConfig('memory');
+    if (memoryAgentConfigured) {
+        const PROMOTION_INTERVAL_MS = Math.max(1, Number(process.env.MAMA_MEMORY_PROMOTION_HOURS) || 6) * 60 * 60 * 1000;
+        const PROMOTION_INITIAL_DELAY_MS = 10 * 60 * 1000; // let connectors poll first
+        const buildPromotionPrompt = (nowIso) => 'PROMOTION RUN. You are curating durable business memory from recent data. ' +
+            `The current time is ${nowIso}.\n` +
+            '1. agent_notices({limit: 100}): find your latest promotion notice (action "promoted" ' +
+            'or "no_update") and treat it as the boundary; default to the last 24h when absent.\n' +
+            '2. kagemusha_entities({activeOnly: true}) to find the rooms active since the boundary, ' +
+            'then kagemusha_messages({channelId, since: <boundary ISO>}) on the busiest 3-4 rooms.\n' +
+            '3. For each candidate judgment, mama_search first to find the existing topic; reuse it ' +
+            'so the evolution chain stays intact.\n' +
+            '4. Promote at most 5 durable judgments per run via mama_save, following the PROMOTION RUN ' +
+            'rules in your persona (pricing/scope agreements, standing client preferences, process ' +
+            'rules, recurring risk patterns; NEVER task lifecycle states, greetings, or logistics). ' +
+            'Include scopes (the source channel, and the project when identifiable) and event_date.\n' +
+            '5. Finish with exactly PROMOTED <n> or NO_UPDATE.';
+        const doPromotionRun = async () => {
+            if (!toolExecutor.getAgentProcessManager()) {
+                routesLogger.warn('[Memory Promotion] AgentProcessManager not available yet');
+                return;
+            }
+            try {
+                const { response, noUpdate } = await executeValidatedRun('memory', buildPromotionPrompt(new Date().toISOString()), { requestTimeout: 600_000 });
+                const promotedMatch = response?.match(/PROMOTED\s+(\d+)/);
+                const saved = promotedMatch ? Number(promotedMatch[1]) : 0;
+                eventBus.emit({
+                    type: 'agent:action',
+                    agent: 'Memory Agent',
+                    action: noUpdate || saved === 0 ? 'no_update' : 'promoted',
+                    target: `promotion run: ${saved} saved`,
+                });
+                if (saved > 0) {
+                    eventBus.emit({ type: 'memory:promoted', saved });
+                    console.log(`[Memory Promotion] Promoted ${saved} durable judgments`);
                 }
-            };
-            // Event-driven: compile when extraction completes (debounced)
-            eventBus.on('extraction:completed', () => runWikiAgent());
-            // Emit agent:action notices when wiki pages are compiled
-            eventBus.on('wiki:compiled', (event) => {
-                if (event.type === 'wiki:compiled') {
-                    for (const page of event.pages) {
-                        eventBus.emit({
-                            type: 'agent:action',
-                            agent: 'Wiki Agent',
-                            action: 'compiled',
-                            target: page,
-                        });
-                    }
+                else {
+                    routesLogger.debug('[Memory Promotion] Nothing qualified for promotion');
                 }
-            });
-            // Manual trigger API
-            apiServer.app.post('/api/wiki/compile', auth_middleware_js_1.requireAuth, async (_req, res) => {
-                runWikiAgent().catch(() => { });
-                res.json({ ok: true, message: 'Wiki compilation triggered' });
-            });
-            // First run after 15s (let connectors and dashboard agent go first)
-            setTimeout(runWikiAgent, 15_000);
-            routesLogger.info('[Wiki Agent] Ready — triggers: extraction:completed event, POST /api/wiki/compile');
-        }
+            }
+            catch (err) {
+                routesLogger.error('[Memory Promotion] Error:', err instanceof Error ? err.message : err);
+            }
+        };
+        // Serialize all promotion runs on one chain (same 'Process is busy' class
+        // as the dashboard and wiki agents).
+        let promotionRunChain = Promise.resolve();
+        const runMemoryPromotion = () => {
+            promotionRunChain = promotionRunChain.then(doPromotionRun).catch(() => { });
+            return promotionRunChain;
+        };
+        setTimeout(runMemoryPromotion, PROMOTION_INITIAL_DELAY_MS);
+        setInterval(runMemoryPromotion, PROMOTION_INTERVAL_MS);
+        apiServer.app.post('/api/memory/promote', auth_middleware_js_1.requireAuth, (_req, res) => {
+            runMemoryPromotion().catch(() => { });
+            res.json({ ok: true, message: 'Memory promotion run triggered' });
+        });
+        console.log(`[Memory Promotion] Ready: every ${PROMOTION_INTERVAL_MS / 3_600_000}h, POST /api/memory/promote`);
     }
     // ── Conductor Audit — hourly system health check ──────────────────────
-    {
-        const AUDIT_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
-        const AUDIT_INITIAL_DELAY_MS = 5 * 60 * 1000; // 5 min after startup
-        const auditPrompt = 'Perform a system audit. Read ~/.mama/skills/audit-checklist.md and execute each step. ' +
-            'Classify findings as MINOR or MAJOR. ' +
-            'For MINOR items: execute the auto-fix command immediately (Bash curl). Do NOT just report — fix it. ' +
-            'For MAJOR items: report to human via channel alert. ' +
-            'Do NOT save raw audit results or audit logs as mama_save decisions. ' +
-            'Only call mama_save when the audit produces a durable policy/remediation decision or reusable lesson; otherwise rely on validation sessions and agent_activity for the audit record.';
-        const runConductorAudit = async () => {
-            let auditSession = null;
-            let auditVersion = 0;
-            const auditStart = Date.now();
+    const AUDIT_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
+    const AUDIT_INITIAL_DELAY_MS = 5 * 60 * 1000; // 5 min after startup
+    // Owner verdict 2026-07-11: the hourly audit re-sent the same MAJOR alert every
+    // run because each audit was stateless. agent_notices does not carry audit
+    // findings (review feedback on #134), so dedup state lives in a JSON file the
+    // conductor reads/writes itself, and the current time is interpolated per run
+    // so the 24h comparison is grounded.
+    const buildAuditPrompt = (nowIso) => 'Perform a system audit. Read ~/.mama/skills/audit-checklist.md and execute each step. ' +
+        'Classify findings as MINOR or MAJOR. ' +
+        'For MINOR items: execute the auto-fix command immediately (Bash curl). Do NOT just report — fix it. ' +
+        'For MAJOR items: report to human via channel alert, subject to the dedup rule below. ' +
+        `Alert dedup (MANDATORY): the current time is ${nowIso}. Read ~/.mama/state/audit-findings.json ` +
+        '(it may not exist on the first run). Re-alert a MAJOR finding only if it is NEW (no entry ' +
+        'with the same id), has ESCALATED, or its last_alerted_at is older than 24 hours compared to ' +
+        'the current time; otherwise stay silent about it. Never alert MINOR findings to the owner. ' +
+        'After the audit, Write ~/.mama/state/audit-findings.json with an array of every current ' +
+        'finding: {id (stable kebab-case slug), severity, first_seen, last_seen, last_alerted_at}. ' +
+        'Carry forward first_seen and last_alerted_at from the previous file; set last_alerted_at to ' +
+        'the current time only for findings you actually alerted this run. ' +
+        // Owner verdict 2026-07-10: hourly-audit self-notes are memory noise -- the two
+        // "durable policy" saves it produced were unscoped near-duplicates polluting
+        // global recall. The audit record lives in validation sessions + agent_activity;
+        // MAJOR findings reach the owner via the channel alert. No memory writes here.
+        'Do NOT call mama_save under any circumstances: the validation session and agent_activity ' +
+        'are the durable audit record, and repeated audits must not accumulate policy notes in memory.';
+    const runConductorAudit = async () => {
+        let auditSession = null;
+        let auditVersion = 0;
+        const auditStart = Date.now();
+        try {
+            routesLogger.debug('[Conductor Audit] Starting hourly audit...');
             try {
-                routesLogger.debug('[Conductor Audit] Starting hourly audit...');
+                const ver = sessionsDb ? (0, agent_store_js_1.getLatestVersion)(sessionsDb, 'conductor') : null;
+                auditVersion = ver?.version ?? 0;
+                auditSession =
+                    validationService?.startSession('conductor', auditVersion, 'audit', {
+                        goal: 'hourly system audit',
+                    }) ?? null;
+            }
+            catch (bootstrapErr) {
+                routesLogger.warn('[Conductor Audit] Failed to initialize audit telemetry:', bootstrapErr);
+                auditVersion = 0;
+                auditSession = null;
+            }
+            if (sessionsDb) {
                 try {
-                    const ver = sessionsDb ? (0, agent_store_js_1.getLatestVersion)(sessionsDb, 'conductor') : null;
-                    auditVersion = ver?.version ?? 0;
-                    auditSession =
-                        validationService?.startSession('conductor', auditVersion, 'audit', {
-                            goal: 'hourly system audit',
-                        }) ?? null;
-                }
-                catch (bootstrapErr) {
-                    routesLogger.warn('[Conductor Audit] Failed to initialize audit telemetry:', bootstrapErr);
-                    auditVersion = 0;
-                    auditSession = null;
-                }
-                if (sessionsDb) {
-                    try {
-                        const startRow = (0, agent_store_js_1.logActivity)(sessionsDb, {
-                            agent_id: 'conductor',
-                            agent_version: auditVersion,
-                            type: 'audit_start',
-                            input_summary: 'Hourly system audit',
-                            run_id: auditSession?.id,
-                            execution_status: 'started',
-                            trigger_reason: 'audit',
-                        });
-                        if (auditSession) {
-                            try {
-                                validationService?.recordRun(auditSession.id, { activityId: startRow.id });
-                            }
-                            catch (telemetryErr) {
-                                routesLogger.warn('[Conductor Audit] Failed to link startup activity to validation session:', telemetryErr);
-                            }
+                    const startRow = (0, agent_store_js_1.logActivity)(sessionsDb, {
+                        agent_id: 'conductor',
+                        agent_version: auditVersion,
+                        type: 'audit_start',
+                        input_summary: 'Hourly system audit',
+                        run_id: auditSession?.id,
+                        execution_status: 'started',
+                        trigger_reason: 'audit',
+                    });
+                    if (auditSession) {
+                        try {
+                            validationService?.recordRun(auditSession.id, { activityId: startRow.id });
                         }
-                    }
-                    catch (telemetryErr) {
-                        routesLogger.warn('[Conductor Audit] Failed to write startup telemetry:', telemetryErr);
-                    }
-                }
-                const auditChannelId = `conductor-audit-${Date.now()}`;
-                await messageRouter.process({
-                    source: 'system',
-                    channelId: auditChannelId,
-                    userId: 'system',
-                    text: auditPrompt,
-                });
-                const auditDuration = Date.now() - auditStart;
-                try {
-                    if (sessionsDb) {
-                        const activityRow = (0, agent_store_js_1.logActivity)(sessionsDb, {
-                            agent_id: 'conductor',
-                            agent_version: auditVersion,
-                            type: 'audit_complete',
-                            input_summary: 'Hourly system audit',
-                            duration_ms: auditDuration,
-                            run_id: auditSession?.id,
-                            execution_status: 'completed',
-                            trigger_reason: 'audit',
-                        });
-                        if (auditSession) {
-                            validationService?.recordRun(auditSession.id, { activityId: activityRow.id });
+                        catch (telemetryErr) {
+                            routesLogger.warn('[Conductor Audit] Failed to link startup activity to validation session:', telemetryErr);
                         }
                     }
                 }
                 catch (telemetryErr) {
-                    routesLogger.warn('[Conductor Audit] Failed to write completion telemetry:', telemetryErr);
-                }
-                try {
-                    if (auditSession && validationService) {
-                        validationService.finalizeSession(auditSession.id, {
-                            execution_status: 'completed',
-                            metrics: { duration_ms: auditDuration },
-                        });
-                    }
-                }
-                catch (telemetryErr) {
-                    routesLogger.warn('[Conductor Audit] Failed to finalize validation session:', telemetryErr);
+                    routesLogger.warn('[Conductor Audit] Failed to write startup telemetry:', telemetryErr);
                 }
-                routesLogger.debug('[Conductor Audit] Audit complete');
             }
-            catch (err) {
-                const auditDuration = Date.now() - auditStart;
-                try {
-                    if (sessionsDb) {
-                        const failRow = (0, agent_store_js_1.logActivity)(sessionsDb, {
-                            agent_id: 'conductor',
-                            agent_version: auditVersion,
-                            type: 'audit_failed',
-                            input_summary: 'Hourly system audit failed',
-                            error_message: err instanceof Error ? err.message : String(err),
-                            duration_ms: auditDuration,
-                            run_id: auditSession?.id,
-                            execution_status: 'failed',
-                            trigger_reason: 'audit',
-                        });
-                        if (auditSession) {
-                            validationService?.recordRun(auditSession.id, { activityId: failRow.id });
-                        }
+            const auditChannelId = `conductor-audit-${Date.now()}`;
+            await messageRouter.process({
+                source: 'system',
+                channelId: auditChannelId,
+                userId: 'system',
+                text: buildAuditPrompt(new Date().toISOString()),
+            });
+            const auditDuration = Date.now() - auditStart;
+            try {
+                if (sessionsDb) {
+                    const activityRow = (0, agent_store_js_1.logActivity)(sessionsDb, {
+                        agent_id: 'conductor',
+                        agent_version: auditVersion,
+                        type: 'audit_complete',
+                        input_summary: 'Hourly system audit',
+                        duration_ms: auditDuration,
+                        run_id: auditSession?.id,
+                        execution_status: 'completed',
+                        trigger_reason: 'audit',
+                    });
+                    if (auditSession) {
+                        validationService?.recordRun(auditSession.id, { activityId: activityRow.id });
                     }
                 }
-                catch (telemetryErr) {
-                    routesLogger.warn('[Conductor Audit] Failed to write failure telemetry:', telemetryErr);
+            }
+            catch (telemetryErr) {
+                routesLogger.warn('[Conductor Audit] Failed to write completion telemetry:', telemetryErr);
+            }
+            try {
+                if (auditSession && validationService) {
+                    validationService.finalizeSession(auditSession.id, {
+                        execution_status: 'completed',
+                        metrics: { duration_ms: auditDuration },
+                    });
                 }
-                try {
-                    if (auditSession && validationService) {
-                        validationService.finalizeSession(auditSession.id, {
-                            execution_status: 'failed',
-                            error_message: err instanceof Error ? err.message : String(err),
-                            metrics: { duration_ms: auditDuration },
-                        });
+            }
+            catch (telemetryErr) {
+                routesLogger.warn('[Conductor Audit] Failed to finalize validation session:', telemetryErr);
+            }
+            routesLogger.debug('[Conductor Audit] Audit complete');
+        }
+        catch (err) {
+            const auditDuration = Date.now() - auditStart;
+            try {
+                if (sessionsDb) {
+                    const failRow = (0, agent_store_js_1.logActivity)(sessionsDb, {
+                        agent_id: 'conductor',
+                        agent_version: auditVersion,
+                        type: 'audit_failed',
+                        input_summary: 'Hourly system audit failed',
+                        error_message: err instanceof Error ? err.message : String(err),
+                        duration_ms: auditDuration,
+                        run_id: auditSession?.id,
+                        execution_status: 'failed',
+                        trigger_reason: 'audit',
+                    });
+                    if (auditSession) {
+                        validationService?.recordRun(auditSession.id, { activityId: failRow.id });
                     }
                 }
-                catch (telemetryErr) {
-                    routesLogger.warn('[Conductor Audit] Failed to finalize failed session:', telemetryErr);
+            }
+            catch (telemetryErr) {
+                routesLogger.warn('[Conductor Audit] Failed to write failure telemetry:', telemetryErr);
+            }
+            try {
+                if (auditSession && validationService) {
+                    validationService.finalizeSession(auditSession.id, {
+                        execution_status: 'failed',
+                        error_message: err instanceof Error ? err.message : String(err),
+                        metrics: { duration_ms: auditDuration },
+                    });
                 }
-                routesLogger.error('[Conductor Audit] Failed:', err instanceof Error ? err.message : String(err));
             }
-        };
-        setTimeout(() => {
-            runConductorAudit();
-            setInterval(runConductorAudit, AUDIT_INTERVAL_MS);
-        }, AUDIT_INITIAL_DELAY_MS);
-        // Manual trigger
-        apiServer.app.post('/api/conductor/audit', auth_middleware_js_1.requireAuth, async (_req, res) => {
-            runConductorAudit().catch(() => { });
-            res.json({ ok: true, message: 'Conductor audit triggered' });
-        });
-        routesLogger.info('[Conductor Audit] Ready — runs every 60 min, POST /api/conductor/audit for manual trigger');
-    }
+            catch (telemetryErr) {
+                routesLogger.warn('[Conductor Audit] Failed to finalize failed session:', telemetryErr);
+            }
+            routesLogger.error('[Conductor Audit] Failed:', err instanceof Error ? err.message : String(err));
+        }
+    };
+    setTimeout(() => {
+        runConductorAudit();
+        setInterval(runConductorAudit, AUDIT_INTERVAL_MS);
+    }, AUDIT_INITIAL_DELAY_MS);
+    // Manual trigger
+    apiServer.app.post('/api/conductor/audit', auth_middleware_js_1.requireAuth, async (_req, res) => {
+        runConductorAudit().catch(() => { });
+        res.json({ ok: true, message: 'Conductor audit triggered' });
+    });
+    routesLogger.info('[Conductor Audit] Ready — runs every 60 min, POST /api/conductor/audit for manual trigger');
     // ── Memory Agent stats API ────────────────────────────────────────────
     apiServer.app.get('/api/memory-agent/stats', auth_middleware_js_1.requireAuth, (_req, res) => {
         const stats = messageRouter.getMemoryAgentStats();
@@ -1187,7 +1431,7 @@ Keep the report under 2000 characters as it will be sent to Discord.`;
         res.sendFile(node_path_1.default.join(publicDir, 'setup.html'));
     });
     apiServer.app.use(express_1.default.static(publicDir, {
-        setHeaders: (res) => {
+        setHeaders: (res, _filePath) => {
             res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
             res.setHeader('Pragma', 'no-cache');
             res.setHeader('Expires', '0');