@jungjaehoon/mama-os 0.21.0 → 0.22.1

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

@@ -53,8 +53,11 @@ 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 code_audit_js_1 = require("../../observability/code-audit.js");
+const security_monitor_js_1 = require("../../security/security-monitor.js");
 const debugLogger = __importStar(require("@jungjaehoon/mama-core/debug-logger"));
 const { DebugLogger } = debugLogger;
 const routesLogger = new DebugLogger('api-routes');
@@ -200,6 +203,9 @@ async function registerApiRoutes(params) {
     }
     // Wire EventBus to tool executor for agent_notices tool
     toolExecutor.setAgentEventBus(eventBus);
+    (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);
@@ -262,7 +268,9 @@ async function registerApiRoutes(params) {
         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").
@@ -270,13 +278,13 @@ 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 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.
+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.`;
         // Owner-initiated refresh skips the NO_UPDATE delta gate: an explicit
         // request means "rebuild the board now", not "tell me nothing changed".
-        const forcedDashboardPrompt = dashboardPrompt.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 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) {
@@ -287,7 +295,7 @@ This saves resources. Only publish when there is genuinely new information to re
                 // 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 ? forcedDashboardPrompt : dashboardPrompt);
+                const { noUpdate } = await executeValidatedRun('dashboard-agent', opts?.force ? buildForcedDashboardPrompt() : buildDashboardPrompt());
                 console.log(noUpdate
                     ? '[Dashboard Agent] no changes detected, publish skipped'
                     : '[Dashboard Agent] board published');
@@ -296,16 +304,20 @@ This saves resources. Only publish when there is genuinely new information to re
                 routesLogger.error('[Dashboard Agent] Error:', err instanceof Error ? err.message : err);
             }
         };
-        // Serialize ALL dashboard runs (boot, interval, manual) on one chain -- the shared
-        // agent process rejects concurrent requests, so unserialized triggers raced into
-        // 'Process is busy' errors (same pattern as CronWorker's executionQueue).
-        let dashboardRunChain = Promise.resolve();
-        const runDashboardAgent = (opts) => {
-            // Trailing catch keeps one failed link from poisoning every future run:
-            // a rejected chain would silently skip all subsequent .then() links.
-            dashboardRunChain = dashboardRunChain.then(() => doDashboardRun(opts)).catch(() => { });
-            return dashboardRunChain;
+        // 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);
@@ -314,6 +326,112 @@ This saves resources. Only publish when there is genuinely new information to re
             runDashboardAgent({ force: true }).catch(() => { });
             res.json({ ok: true, message: 'Dashboard agent triggered (forced refresh)' });
         });
+        // -- 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');
@@ -503,164 +621,84 @@ This saves resources. Only compile when there is genuinely new information to do
         });
         console.log(`[Memory Promotion] Ready: every ${PROMOTION_INTERVAL_MS / 3_600_000}h, POST /api/memory/promote`);
     }
-    // ── Conductor Audit — hourly system health check ──────────────────────
+    // -- System Audit: hourly deterministic code checks ---------------------
+    // Owner decision 2026-04-22 (mama_conductor_audit_code_based_read_only),
+    // landed 2026-07-17: the audit is fact collection and recording executed by
+    // CODE - no LLM invocation, no auto-fix, no broad filesystem access. The
+    // prior hourly LLM audit violated that decision and the 2026-05-14
+    // no-shell-autofix rule, and lost its tools entirely to the persona
+    // lockdown (--tools ""). The 24h alert-dedup contract (owner verdict
+    // 2026-07-11) is preserved inside runCodeAudit; MAJOR findings flow through
+    // dispatchSecurityAlertDirect to the configured security alert sender.
     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();
+    const doSystemAudit = async () => {
         try {
-            routesLogger.debug('[Conductor Audit] Starting hourly audit...');
-            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',
+            const report = await (0, code_audit_js_1.runCodeAudit)({
+                config: {
+                    telegram: config.telegram,
+                    multi_agent: config.multi_agent,
+                },
+                // Evaluated at audit time: gateway-wiring registers the sender only
+                // for ACTIVE gateways, so a configured target on a dead gateway must
+                // not report a false PASS.
+                securityAlertConfigured: (0, security_monitor_js_1.hasSecurityAlertSender)(),
+                // Direct dispatch, NOT recordSecurityEvent: audit findings are
+                // self-generated and must not fabricate incident/denylist/RDAP
+                // artifacts for a pseudo client. dispatchSecurityAlertDirect awaits
+                // delivery and throws on failure, so runCodeAudit keeps
+                // last_alerted_at null and retries on the next run (fail loud).
+                alert: async (finding, reason) => {
+                    await (0, security_monitor_js_1.dispatchSecurityAlertDirect)({
+                        type: 'system_audit_finding',
+                        severity: 'critical',
+                        message: `[Audit/${reason}] ${finding.summary}`,
+                        // path carries the finding id so the alert-cooldown fingerprint
+                        // distinguishes findings instead of collapsing them all into one.
+                        path: finding.id,
+                        details: { findingId: finding.id, detail: finding.detail ?? null },
                     });
-                    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);
-                        }
-                    }
-                }
-                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: 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 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.debug('[Conductor Audit] Audit complete');
+            const majors = report.findings.filter((f) => f.severity === 'MAJOR').length;
+            const minors = report.findings.filter((f) => f.severity === 'MINOR').length;
+            routesLogger.info(`[System Audit] ${report.pass_items.length} pass, ${majors} MAJOR, ${minors} MINOR, ` +
+                `alerted=[${report.alerted.join(',')}] in ${report.duration_ms}ms`);
+            if (report.alert_delivery_failures.length > 0) {
+                routesLogger.error('[System Audit] Alert delivery failures:', report.alert_delivery_failures.join('; '));
+            }
+            return report;
         }
         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 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 },
-                    });
-                }
-            }
-            catch (telemetryErr) {
-                routesLogger.warn('[Conductor Audit] Failed to finalize failed session:', telemetryErr);
-            }
-            routesLogger.error('[Conductor Audit] Failed:', err instanceof Error ? err.message : String(err));
+            routesLogger.error('[System Audit] Failed:', err instanceof Error ? err.message : String(err));
+            return null;
         }
     };
+    // Serialize scheduled and manual runs (same pattern as the memory-promotion
+    // chain above): overlapping audits would read the same prior state, alert
+    // twice, and race the audit-findings.json write. doSystemAudit never
+    // rejects, so chaining on the previous run is sufficient.
+    let auditRunChain = Promise.resolve(null);
+    const runSystemAudit = () => {
+        const next = auditRunChain.then(doSystemAudit);
+        auditRunChain = next;
+        return next;
+    };
     setTimeout(() => {
-        runConductorAudit();
-        setInterval(runConductorAudit, AUDIT_INTERVAL_MS);
+        void runSystemAudit();
+        setInterval(() => void runSystemAudit(), AUDIT_INTERVAL_MS);
     }, AUDIT_INITIAL_DELAY_MS);
-    // Manual trigger
+    // Manual trigger returns the full report (read-only, no LLM, fast)
     apiServer.app.post('/api/conductor/audit', auth_middleware_js_1.requireAuth, async (_req, res) => {
-        runConductorAudit().catch(() => { });
-        res.json({ ok: true, message: 'Conductor audit triggered' });
+        const report = await runSystemAudit();
+        if (report) {
+            res.json({ ok: true, mode: 'code', report });
+        }
+        else {
+            res.status(500).json({ ok: false, error: 'audit failed - see daemon.log' });
+        }
     });
-    routesLogger.info('[Conductor Audit] Ready — runs every 60 min, POST /api/conductor/audit for manual trigger');
+    routesLogger.info('[System Audit] Ready - deterministic code checks every 60 min, POST /api/conductor/audit for manual run');
     // ── Memory Agent stats API ────────────────────────────────────────────
     apiServer.app.get('/api/memory-agent/stats', auth_middleware_js_1.requireAuth, (_req, res) => {
         const stats = messageRouter.getMemoryAgentStats();