@jungjaehoon/mama-os 0.53.1 → 0.58.0

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

@@ -1,1542 +0,0 @@
-"use strict";
-/**
- * API route registration.
- *
- * Extracted from start.ts (Task 11 Part B).
- * Registers ALL REST endpoints, middleware, static file serving,
- * and wires Dashboard + Wiki agents via AgentProcessManager.
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildReconcileExternalLifecycleCandidates = void 0;
-exports.registerKagemushaTaskRoute = registerKagemushaTaskRoute;
-exports.registerApiRoutes = registerApiRoutes;
-const node_fs_1 = require("node:fs");
-const node_os_1 = require("node:os");
-const express_1 = __importDefault(require("express"));
-const node_path_1 = __importDefault(require("node:path"));
-const node_http_1 = __importDefault(require("node:http"));
-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_act_mcp_config_js_1 = require("../../mcp/code-act-mcp-config.js");
-const code_audit_js_1 = require("../../observability/code-audit.js");
-const workorder_publishers_js_1 = require("../../operator/workorder-publishers.js");
-const workorder_hooks_js_1 = require("../../operator/workorder-hooks.js");
-const board_delta_gate_js_1 = require("../../operator/board-delta-gate.js");
-const wiki_continuity_js_1 = require("../../operator/wiki-continuity.js");
-const external_lifecycle_discovery_js_1 = require("../../operator/external-lifecycle-discovery.js");
-Object.defineProperty(exports, "buildReconcileExternalLifecycleCandidates", { enumerable: true, get: function () { return external_lifecycle_discovery_js_1.buildReconcileExternalLifecycleCandidates; } });
-const security_monitor_js_1 = require("../../security/security-monitor.js");
-const debugLogger = __importStar(require("@jungjaehoon/mama-core/debug-logger"));
-const leg_cadence_js_1 = require("../../operator/leg-cadence.js");
-const { DebugLogger } = debugLogger;
-const routesLogger = new DebugLogger('api-routes');
-const HOST_MANUAL_FULL_REPAIR_CHANNEL = 'host:api-report-agent-refresh';
-function queryString(value) {
-    return typeof value === 'string' ? value : undefined;
-}
-function queryLimit(value) {
-    if (typeof value !== 'string') {
-        return 30;
-    }
-    const limit = Number(value);
-    return Number.isFinite(limit) ? limit : 30;
-}
-function registerKagemushaTaskRoute(app, policy, loadQuery = async () => (await import('../../connectors/kagemusha/query-tools.js')).queryTasks) {
-    if (!policy.isEnabled('kagemusha')) {
-        return;
-    }
-    app.get('/api/kagemusha/tasks', auth_middleware_js_1.requireAuth, async (req, res) => {
-        try {
-            const queryTasks = await loadQuery();
-            const tasks = queryTasks({
-                status: queryString(req.query.status),
-                priority: queryString(req.query.priority),
-                search: queryString(req.query.search),
-                sourceRoom: queryString(req.query.sourceRoom),
-                limit: queryLimit(req.query.limit),
-            });
-            if (req.query.filter === 'overdue') {
-                const now = Date.now();
-                const overdue = tasks.filter((task) => {
-                    return task.deadline !== null && new Date(task.deadline).getTime() < now;
-                });
-                res.json({ success: true, tasks: overdue, total: overdue.length });
-                return;
-            }
-            res.json({ success: true, tasks, total: tasks.length });
-        }
-        catch (error) {
-            res.status(500).json({
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    });
-}
-async function registerApiRoutes(params) {
-    const { config, apiServer, eventBus, oauthManager: _oauthManager, mamaApi: _mamaApi, messageRouter, toolExecutor, discordGateway, slackGateway, graphHandler, getAdapter, privateConnectorPolicy, rawConnectorScope, sessionsDb, workOrderConsumer, boardRefreshGate, } = params;
-    let boardBootTimeout = null;
-    let boardInterval = null;
-    let wikiContinuityInterval = null;
-    let boardReconcileScheduler = null;
-    let boardReconcileEnabled = false;
-    let requestBoardRepair = () => {
-        routesLogger.error('[stage2] Board repair nudge ignored: dashboard-agent is not configured');
-    };
-    // ── Stage-2 workorder publishers ──────────────────────────────────────
-    // The ONLY system run path since v0.28.0: every scheduled/boot/manual run
-    // below enqueues an occurrence-keyed workorder for the consumer lane (the
-    // legacy executeValidatedRun persona runs were removed after the 2026-07-22
-    // production cutover).
-    const enqueueWorkOrderOrThrow = (workKind, idempotencyKey, payload, priority) => {
-        const ledger = toolExecutor.getTaskLedger();
-        if (!ledger) {
-            throw new Error(`[stage2] TaskLedger unavailable - cannot enqueue ${workKind} workorder`);
-        }
-        (0, workorder_publishers_js_1.validateWorkOrderPayload)(workKind, payload);
-        const wo = ledger.enqueueWorkOrder({ workKind, idempotencyKey, input: payload, priority });
-        console.log(`[stage2] enqueued workorder ${workKind}#${wo.id} key=${idempotencyKey}`);
-        return wo;
-    };
-    // 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);
-    };
-    // ── Report Slots + legacy dashboard/wiki fanout ───────────────────────
-    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' });
-    });
-    apiServer.app.post('/api/operator/report', auth_middleware_js_1.requireAuth, (_req, res) => {
-        const outcome = params.requestFullReport?.() ?? {
-            accepted: false,
-            reason: 'unavailable',
-        };
-        if (outcome.accepted) {
-            res.status(202).json({ ok: true, status: 'accepted' });
-            return;
-        }
-        const status = outcome.reason === 'busy' ? 409 : 503;
-        res.status(status).json({ ok: false, reason: outcome.reason ?? 'unavailable' });
-    });
-    // -- TG-05/TG-06 owner-report delivery recovery (design Decision 3) --
-    // A definite rejection is never retried automatically; these explicit
-    // operator actions are the ONLY way to reactivate the same delivery ID or
-    // to cancel a proven-unaccepted occurrence. The trigger loop observes the
-    // resulting terminal/retryable state on its next tick.
-    const reportContextStore = params.reportContextStore;
-    if (reportContextStore) {
-        apiServer.app.get('/api/operator/report-delivery/:deliveryId', auth_middleware_js_1.requireAuth, (req, res) => {
-            const event = reportContextStore.getEvent(String(req.params.deliveryId));
-            if (!event) {
-                res.status(404).json({ ok: false, error: 'unknown delivery ID' });
-                return;
-            }
-            res.json({ ok: true, event });
-        });
-        const isProtocolRefusal = (error) => error instanceof Error && /cannot be (cancelled|reactivated)/i.test(error.message);
-        apiServer.app.post('/api/operator/report-delivery/reactivate', auth_middleware_js_1.requireAuth, (req, res) => {
-            const deliveryId = (req.body ?? {}).deliveryId;
-            if (typeof deliveryId !== 'string' || deliveryId.length === 0) {
-                res.status(400).json({ ok: false, error: 'deliveryId must be a non-empty string' });
-                return;
-            }
-            try {
-                reportContextStore.reactivate(deliveryId);
-                res.json({
-                    ok: true,
-                    message: `delivery ${deliveryId} reactivated; next due tick retries`,
-                });
-            }
-            catch (error) {
-                res.status(isProtocolRefusal(error) ? 409 : 500).json({
-                    ok: false,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-        });
-        apiServer.app.post('/api/operator/report-delivery/cancel', auth_middleware_js_1.requireAuth, (req, res) => {
-            const body = (req.body ?? {});
-            const deliveryId = body.deliveryId;
-            const reason = body.reason;
-            if (typeof deliveryId !== 'string' ||
-                deliveryId.length === 0 ||
-                typeof reason !== 'string' ||
-                reason.length === 0) {
-                res
-                    .status(400)
-                    .json({ ok: false, error: 'deliveryId and reason must be non-empty strings' });
-                return;
-            }
-            try {
-                reportContextStore.cancel(deliveryId, reason, new Date().toISOString());
-                res.json({ ok: true, message: `delivery ${deliveryId} cancelled` });
-            }
-            catch (error) {
-                res.status(isProtocolRefusal(error) ? 409 : 500).json({
-                    ok: false,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-        });
-    }
-    if (config.agent.backend === 'claude') {
-        // Merge code-act MCP server into mama-mcp-config.json. The owner runtime's
-        // own claude persona needs this entry, so it is NOT gated on any legacy
-        // self-paced agent (dashboard-agent / wiki-agent) being configured.
-        try {
-            (0, code_act_mcp_config_js_1.ensureCodeActMcpConfig)({
-                mcpConfigPath: node_path_1.default.join((0, node_os_1.homedir)(), '.mama', 'mama-mcp-config.json'),
-                apiPort: utilities_js_1.API_PORT,
-                logger: routesLogger,
-            });
-        }
-        catch (err) {
-            routesLogger.warn('[api-routes-init] Failed to merge code-act into MCP config:', err);
-        }
-    }
-    // report_publish is a core surface (feeds the /viewer 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));
-        // S1-T4 artifact hub: the console READS the board it directs. Same store
-        // the publisher writes - MAMA's status answers cite these slots
-        // instead of re-deriving state from memory copies.
-        toolExecutor.setReportReader(() => {
-            const slots = apiServer.reportStore.getAll();
-            const projected = {};
-            for (const [name, slot] of Object.entries(slots)) {
-                projected[name] = {
-                    html: slot.html,
-                    basisRevision: slot.basisRevision,
-                    currentBasisRevision: slot.currentBasisRevision,
-                    freshness: slot.freshness,
-                    updatedAt: Number.isFinite(slot.updatedAt)
-                        ? new Date(slot.updatedAt).toISOString()
-                        : null,
-                };
-            }
-            return projected;
-        });
-    }
-    {
-        // ── Stage-2 Board publisher and verifier ───────────────────────────
-        // Schedule/boot/manual all funnel here: one occurrence-keyed board
-        // workorder per entry. An enqueue failure is logged loudly and the next
-        // occurrence retries - there is no fallback run path.
-        const reconcileEnabled = process.env.MAMA_BOARD_RECONCILE === '1';
-        boardReconcileEnabled = reconcileEnabled;
-        // Evidence that a board was actually WRITTEN, not just that a run reached
-        // 'done'. An unverified full run reaches 'done' too, so the delta gate
-        // requires a publish at or after the baseline run's enqueue time.
-        const boardPublishedAt = () => {
-            const slots = apiServer.reportStore.getAll();
-            let oldest = Number.POSITIVE_INFINITY;
-            for (const slotId of workorder_hooks_js_1.REQUIRED_FULL_BOARD_SLOTS) {
-                const updatedAt = slots[slotId]?.updatedAt;
-                if (!Number.isFinite(updatedAt))
-                    return 0;
-                oldest = Math.min(oldest, updatedAt);
-            }
-            return Number.isFinite(oldest) ? oldest : 0;
-        };
-        const runDashboardAgent = (opts) => {
-            try {
-                // Cheap host-side delta gate (Fix E). It runs in BOTH configs, because
-                // under MAMA_BOARD_RECONCILE=1 every scheduled enqueue reaches this
-                // line WITH dirt: `needsFullRepair()` is true whenever a channel delta
-                // or an owner board request arrived since the last verified full run
-                // (board-refresh-gate.ts), which is an "inputs moved" claim - exactly
-                // the claim this gate re-checks against what the board actually reads.
-                // The "board was not rebuilt" case is NOT suppressed: it surfaces as
-                // the gate's own `unpublished` reason, measured from the report slots
-                // rather than assumed. A broken signal enqueues as before -
-                // availability of the board beats the token saving - but says so.
-                const delta = (0, board_delta_gate_js_1.evaluateBoardFullDelta)({
-                    readWatermark: () => {
-                        const ledger = toolExecutor.getTaskLedger();
-                        if (!ledger) {
-                            throw new Error('TaskLedger unavailable - cannot read the board input watermark');
-                        }
-                        const adapter = getAdapter();
-                        return (0, board_delta_gate_js_1.composeBoardInputWatermark)([
-                            (0, board_delta_gate_js_1.connectorObservationTerm)(adapter),
-                            ledger.ownerTaskTerm(),
-                            (0, board_delta_gate_js_1.memoryRecencyTerm)(adapter),
-                        ]);
-                    },
-                    readBaseline: () => {
-                        const ledger = toolExecutor.getTaskLedger();
-                        if (!ledger) {
-                            throw new Error('TaskLedger unavailable - cannot read the full-board baseline');
-                        }
-                        return ledger.lastCompletedBoardFullRun();
-                    },
-                    readBoardPublishedAt: boardPublishedAt,
-                });
-                if (delta.warning) {
-                    // error, not warn: DebugLogger defaults to MAMA_LOG_LEVEL=ERROR, so a
-                    // warn here would be invisible on a normal daemon - and a gate whose
-                    // signal is broken is permanently inert, which is exactly the kind of
-                    // silent degradation this file logs loudly everywhere else.
-                    routesLogger.error(`[stage2] board delta gate unavailable (${delta.warning}); enqueueing the full board anyway`);
-                }
-                // Two independent authorities, and neither of them is "the daemon just
-                // started" (owner decision 2026-09-09). `delta` means the watermark
-                // moved, and the in-memory gate must agree that something actually
-                // arrived - the notices term of that watermark is an in-memory ring, so
-                // a restart alone changes it and used to buy one full run per boot. The
-                // other reasons are EVIDENCE about the board itself (no baseline, never
-                // published, stale past DEFAULT_BOARD_FULL_MAX_STALENESS_MS, or a signal
-                // we could not read), and those still enqueue on their own: availability
-                // of the board beats the token saving.
-                const gateDirty = boardRefreshGate ? boardRefreshGate.needsFullRepair() : true;
-                // 'unpublished' is the ONE reason that must still agree with the in-memory dirt: a
-                // board whose last completed run honestly had nothing to publish stays unpublished
-                // forever, so on its own this reason would re-enqueue every 30 minutes for the rest
-                // of the daemon's life. Every other reason is bounded on its own - 'no-baseline'
-                // fires once, 'stale' at most once per DEFAULT_BOARD_FULL_MAX_STALENESS_MS, 'delta'
-                // only when a durable term actually moved, and 'signal-unavailable' is the case
-                // where availability of the board beats the token saving.
-                const needsDirtAgreement = delta.reason === 'unpublished';
-                if (!opts?.force && !delta.enqueue) {
-                    routesLogger.info(`[stage2] board full skipped: ${delta.reason} - nothing the board reads has moved since the last published full run`);
-                    return;
-                }
-                if (!opts?.force && needsDirtAgreement && !gateDirty) {
-                    routesLogger.info(`[stage2] board full skipped: ${delta.reason} with a clean repair gate - the last completed run had nothing to publish and nothing has arrived since`);
-                    return;
-                }
-                // The skips say why nothing ran; this says why something did. Without it a boot
-                // enqueue was the one board decision with no reason on the record.
-                // A forced refresh is always a rebuild; otherwise the gate decides (board-delta-gate.ts).
-                const runMode = opts?.force ? 'full' : delta.mode;
-                const anchorPublishedAt = runMode === 'delta' ? delta.anchorPublishedAt : null;
-                const anchor = anchorPublishedAt === null ? null : new Date(anchorPublishedAt).toISOString();
-                // The basis the published board rests on, read from the SAME report slots the anchor
-                // came from - not a fresh read, so the turn is told the basis of what it is editing.
-                const anchorBasis = anchor === null
-                    ? null
-                    : (apiServer.reportStore.get('pipeline')?.currentBasisRevision ?? null);
-                // An anchored decision the store cannot name a basis for is not a delta: the turn would
-                // have to invent the basis it publishes under. Rebuild instead of guessing.
-                const mode = runMode === 'delta' && anchor !== null && anchorBasis !== null ? 'delta' : 'full';
-                if (mode === 'delta') {
-                    routesLogger.info(`[stage2] board delta enqueued: ${delta.reason} (anchor ${String(anchor)}, basis ${String(anchorBasis)})`);
-                }
-                else {
-                    routesLogger.info(`[stage2] board full enqueued: ${opts?.force ? 'force' : delta.reason} (watermark ${delta.watermark ?? 'unavailable'})`);
-                }
-                if (opts?.force && boardRefreshGate) {
-                    // Host-owned manual dirt is captured before validation/enqueue can
-                    // fail. It clears only through the full run-bound effect verifier.
-                    boardRefreshGate.markChannelDirty(HOST_MANUAL_FULL_REPAIR_CHANNEL);
-                }
-                const now = Date.now();
-                const repair = boardRefreshGate?.captureFullRepair();
-                const ledger = toolExecutor.getTaskLedger();
-                if (!ledger) {
-                    throw new Error('TaskLedger unavailable - cannot issue reclassification candidates');
-                }
-                const reclassificationCandidates = ledger
-                    .list({
-                    includeTerminal: false,
-                    qualification: 'legacy_unqualified',
-                    order: 'deadline_priority',
-                    limit: 10,
-                })
-                    .map((task) => ({ taskId: task.id, taskRevision: task.revision }));
-                enqueueWorkOrderOrThrow('board', opts?.force
-                    ? (0, workorder_publishers_js_1.boardManualKey)(now)
-                    : boardRefreshGate
-                        ? (0, workorder_publishers_js_1.boardRepairKey)()
-                        : (0, workorder_publishers_js_1.boardFullKey)(now), {
-                    mode,
-                    ...(mode === 'delta'
-                        ? { deltaAnchor: anchor, deltaBasisRevision: anchorBasis }
-                        : {}),
-                    ...(repair ?? {}),
-                    // Carried so this run's completion becomes the next tick's baseline.
-                    ...(delta.watermark === null ? {} : { deltaWatermark: delta.watermark }),
-                    reclassificationCandidates,
-                    ...(opts?.force ? { force: true } : {}),
-                }, opts?.force ? 'high' : undefined);
-            }
-            catch (err) {
-                routesLogger.error('[stage2] board enqueue failed:', err instanceof Error ? err.message : err);
-            }
-        };
-        // Host-gated repair: runs only when the gate is dirty or the delta moved.
-        requestBoardRepair = () => runDashboardAgent();
-        // First run after 10s (let connectors poll first), then every 30 min
-        // ONE constant feeds both the timer and the declared cadence - if they
-        // drift apart the watchdog pages on a schedule nobody is running.
-        const DASHBOARD_AGENT_INTERVAL_MS = 30 * 60 * 1000;
-        boardBootTimeout = setTimeout(() => {
-            runDashboardAgent();
-        }, 10_000);
-        (0, leg_cadence_js_1.getLegCadence)()?.declare('dashboard-agent', DASHBOARD_AGENT_INTERVAL_MS);
-        boardInterval = setInterval(() => {
-            (0, leg_cadence_js_1.getLegCadence)()?.beat('dashboard-agent');
-            runDashboardAgent();
-        }, DASHBOARD_AGENT_INTERVAL_MS);
-        // Manual trigger (owner-forced: the workorder carries force=true so the
-        // worker brief skips its NO_UPDATE delta gate)
-        apiServer.app.post('/api/report/agent-refresh', auth_middleware_js_1.requireAuth, async (_req, res) => {
-            runDashboardAgent({ force: true });
-            res.json({ ok: true, message: 'Board refresh workorder enqueued (forced)' });
-        });
-        // Manual Board reconcile remains available for an explicit operator
-        // request. Connector deltas belong to the MAMA owner-event agent and are
-        // no longer consumed by a parallel Board worker.
-        if (reconcileEnabled && boardRefreshGate) {
-            const { ReconcileScheduler } = await import('../../operator/board-reconcile.js');
-            const { captureSnapshot, verifyAfterRun } = await import('../../operator/action-verifier.js');
-            // Verifier deps (M8 Phase 2): run-bound signals only -- notes from the
-            // operator ledger, board slots. Observe, never block. Trace queries are
-            // worker-keyed (buildWorkerTraceQueries below): reconcile runs execute
-            // on the workorder consumer lane only.
-            const reconcileLedger = toolExecutor.getTaskLedger();
-            const verifierDeps = {
-                getSlots: () => apiServer.reportStore.getAllSorted(),
-                getLedgerHash: () => reconcileLedger?.payloadHash() ?? '',
-                getScopedNoteMaxId: (scope) => reconcileLedger?.maxNoUpdateId(scope) ?? 0,
-            };
-            // Stage-2 board completion hook (plan D1/E3/G1): the consumer wraps
-            // reconcile workorders with the SAME bracket the legacy closure owns,
-            // but trace rows from worker runs carry the worker's identity, not
-            // agent_id='dashboard-agent' - the re-key goes through details JSON
-            // (agent_activity has NO channel_id column; json_extract is the only
-            // schema-supported key; agent_id re-keying is a green-test trap).
-            if (workOrderConsumer) {
-                const { applyBoardRefreshVerdict, buildFullBoardTraceQueries, buildWorkerTraceQueries, boardCandidateReceiptVerdict, } = await import('../../operator/workorder-hooks.js');
-                // Per ATTEMPT, not per lane: a sibling board order running inside a delegated
-                // attempt's window must not discharge it (review P1-1).
-                const reconcileVerifierDepsFor = (attemptId) => ({
-                    ...verifierDeps,
-                    ...buildWorkerTraceQueries(sessionsDb, 'worker:board', undefined, attemptId),
-                });
-                const fullVerifierDepsFor = (attemptId) => ({
-                    ...verifierDeps,
-                    ...buildFullBoardTraceQueries(sessionsDb, 'worker:board', attemptId),
-                });
-                workOrderConsumer.registerHook('board', {
-                    verdictRequired: true,
-                    before: (wo) => {
-                        if (wo.payload.mode === 'reconcile') {
-                            return captureSnapshot(reconcileVerifierDepsFor(wo.id), `reconcile:${String(wo.payload.channelKey)}`);
-                        }
-                        if (wo.payload.mode !== 'reconcile' && typeof wo.payload.noUpdateScope === 'string') {
-                            return captureSnapshot(fullVerifierDepsFor(wo.id), wo.payload.noUpdateScope);
-                        }
-                        return null;
-                    },
-                    after: (wo, response, beforeState) => {
-                        const receiptVerdict = boardCandidateReceiptVerdict(wo, reconcileLedger);
-                        if (!beforeState) {
-                            if (response.includes('NO_UPDATE')) {
-                                console.log('[stage2] board worker: no changes detected, publish skipped');
-                            }
-                            return receiptVerdict;
-                        }
-                        const isReconcile = wo.payload.mode === 'reconcile';
-                        const scope = isReconcile
-                            ? `reconcile:${String(wo.payload.channelKey)}`
-                            : String(wo.payload.noUpdateScope);
-                        const verdict = verifyAfterRun(isReconcile ? reconcileVerifierDepsFor(wo.id) : fullVerifierDepsFor(wo.id), beforeState, scope);
-                        // force:true is a request to rebuild/publish, so an exact no-op
-                        // note cannot discharge it. Non-force scheduled repair may use
-                        // the exact scope note when there is genuinely nothing to write.
-                        const effectVerified = verdict.verified &&
-                            !(wo.payload.mode !== 'reconcile' &&
-                                wo.payload.force === true &&
-                                verdict.obligatedTraceCount === 0);
-                        // The mode is named in the outcome: a verified delta and a verified full are
-                        // different claims about how the board was produced, and `full_verified` on a delta
-                        // run would hide which one actually happened.
-                        const boardMode = wo.payload.mode === 'delta' ? 'delta' : 'full';
-                        const outcome = effectVerified
-                            ? isReconcile
-                                ? 'reconcile_verified'
-                                : `${boardMode}_verified`
-                            : isReconcile
-                                ? 'reconcile_unverified'
-                                : `${boardMode}_unverified`;
-                        console.log(`[stage2] ${outcome} scope=${scope}${verdict.effects.length > 0 ? ` (${verdict.effects.join('; ')})` : ''}`);
-                        try {
-                            if (sessionsDb) {
-                                (0, agent_store_js_1.logActivity)(sessionsDb, {
-                                    agent_id: 'workorder-board',
-                                    agent_version: 0,
-                                    type: outcome,
-                                    input_summary: scope,
-                                    output_summary: verdict.effects.join('; '),
-                                    execution_status: 'completed',
-                                    trigger_reason: 'workorder',
-                                });
-                            }
-                        }
-                        catch {
-                            /* telemetry only */
-                        }
-                        if (!effectVerified) {
-                            eventBus.emit({
-                                type: 'agent:action',
-                                agent: 'Dashboard Agent',
-                                action: isReconcile ? 'reconcile_unverified' : 'full_unverified',
-                                target: isReconcile ? String(wo.payload.channelKey) : scope,
-                            });
-                        }
-                        return applyBoardRefreshVerdict(wo, effectVerified, receiptVerdict, boardRefreshGate);
-                    },
-                });
-            }
-            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, eventIds, repairGeneration) => {
-                    // The reconcile leg is a board workorder; its bracket verification
-                    // runs in the consumer's completion hook (registered above).
-                    try {
-                        const privateKagemushaPartition = channelKey.startsWith('kagemusha:');
-                        const mayProjectKagemushaLifecycle = privateConnectorPolicy.isEnabled('kagemusha') &&
-                            rawConnectorScope.includes('kagemusha');
-                        if (privateKagemushaPartition && !mayProjectKagemushaLifecycle) {
-                            // A private partition that boot did not authorize is consumed
-                            // without a generic board workorder. Rejecting would retain and
-                            // retry the private delta; enqueuing would leak its prose.
-                            boardRefreshGate.consumeUnauthorizedPartition(channelKey, repairGeneration);
-                            return Promise.resolve();
-                        }
-                        const ledger = toolExecutor.getTaskLedger();
-                        if (!ledger) {
-                            throw new Error('[stage2] TaskLedger unavailable - cannot construct lifecycle evidence');
-                        }
-                        const candidates = (0, external_lifecycle_discovery_js_1.buildReconcileExternalLifecycleCandidates)({
-                            eventIds,
-                            getAdapter,
-                            ledger,
-                            privateConnectorPolicy,
-                            rawConnectorScope,
-                        });
-                        const reclassificationCandidates = ledger
-                            .list({ channel: channelKey, order: 'updated', limit: 10 })
-                            .map((task) => ({ taskId: task.id, taskRevision: task.revision }));
-                        enqueueWorkOrderOrThrow('board', (0, workorder_publishers_js_1.boardReconcileKey)(channelKey, Date.now()), {
-                            mode: 'reconcile',
-                            channelKey,
-                            deltaLines,
-                            // The batch, carried structurally. It was already inside deltaLines as
-                            // `[id:evt_...]` text and could only be recovered by parsing prose.
-                            eventIds,
-                            repairGeneration,
-                            reclassificationCandidates,
-                            // Host-authored structural authority. deltaLines remain untrusted,
-                            // human-readable context and never grant lifecycle mutations.
-                            candidates,
-                        });
-                    }
-                    catch (err) {
-                        routesLogger.error('[stage2] reconcile enqueue failed:', err instanceof Error ? err.message : err);
-                        // REJECT so ReconcileScheduler restores pendingLines - a
-                        // resolved failure silently drops this delta (PR bot round).
-                        return Promise.reject(err instanceof Error ? err : new Error(String(err)));
-                    }
-                    return Promise.resolve();
-                },
-            });
-            boardReconcileScheduler = reconcileScheduler;
-            // 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 (typeof channelKey !== 'string' ||
-                    channelKey.length === 0 ||
-                    channelKey.length > 1000 ||
-                    !Array.isArray(lines) ||
-                    lines.length === 0) {
-                    res.status(400).json({
-                        ok: false,
-                        error: 'channelKey (1-1000 chars) and non-empty lines[] are required',
-                    });
-                    return;
-                }
-                const repairGeneration = boardRefreshGate.markChannelDirty(channelKey);
-                reconcileScheduler.enqueue(channelKey, lines, [], repairGeneration);
-                res.json({ ok: true, message: 'Reconcile queued (async; runs after debounce)' });
-            });
-            console.log('[reconcile] Board reconcile leg enabled (MAMA_BOARD_RECONCILE=1)');
-        }
-    }
-    // ── Wiki Agent ──────────────────────────────────────────────────────
-    const wikiConfig = config.wiki;
-    if (wikiAgentConfigured && wikiConfig?.enabled && wikiConfig.vaultPath) {
-        const { ObsidianWriter } = await import('../../wiki/obsidian-writer.js');
-        const obsWriter = new ObsidianWriter(wikiConfig.vaultPath, wikiConfig.wikiDir || 'wiki');
-        obsWriter.ensureDirectories();
-        routesLogger.debug(`[Wiki Agent] 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' && !process.env.VITEST) {
-            try {
-                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 */
-            }
-        }
-        // Wire wiki_publish tool to shared gateway executor (used by code-act path)
-        toolExecutor.setWikiPublisher((pages) => {
-            const scheduledPages = pages.every((page) => page.expectedContentVersion !== undefined);
-            if (scheduledPages) {
-                // Home.md is the v5 index and is part of the staged page set. Legacy index.md/log.md
-                // writes stay on the generic path so a scheduled publish has one rollback boundary.
-                obsWriter.writePagesAtomically(pages);
-            }
-            else {
-                for (const page of pages) {
-                    obsWriter.writePage(page);
-                }
-                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 || ''),
-            });
-        });
-        // Owner/host IANA time zone - the same source the temporal runtime and the
-        // TaskLedger derive the owner day from.
-        const wikiTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-        // The wiki source watermark covers connector observation, native owner tasks
-        // and memory recency. Agent notices are DELIBERATELY EXCLUDED: a wiki
-        // completion/no-update notice must not move the watermark and so wake the
-        // wiki turn forever.
-        const readWikiSourceWatermark = () => {
-            const ledger = toolExecutor.getTaskLedger();
-            if (!ledger) {
-                throw new Error('TaskLedger unavailable - cannot read the wiki source watermark');
-            }
-            const adapter = getAdapter();
-            return (0, wiki_continuity_js_1.composeWikiSourceWatermark)([
-                (0, board_delta_gate_js_1.connectorObservationTerm)(adapter),
-                ledger.ownerTaskTerm(),
-                (0, board_delta_gate_js_1.memoryRecencyTerm)(adapter),
-            ]);
-        };
-        const runWikiAgent = (trigger, opts) => {
-            try {
-                const now = Date.now();
-                const ledger = toolExecutor.getTaskLedger();
-                if (!ledger) {
-                    throw new Error('TaskLedger unavailable - cannot plan a wiki run');
-                }
-                const decision = (0, wiki_continuity_js_1.evaluateWikiContinuity)({
-                    nowMs: now,
-                    timeZone: wikiTimeZone,
-                    connectors: (0, wiki_continuity_js_1.publicWikiConnectorScope)(rawConnectorScope, privateConnectorPolicy.enabledPrivateConnectors),
-                    trigger,
-                    forced: opts?.forced === true,
-                    requestedOwnerDate: opts?.ownerDate,
-                    readSourceWatermark: readWikiSourceWatermark,
-                    readBaseline: () => ledger.lastCompletedWikiRun(),
-                });
-                if (decision.warning) {
-                    routesLogger.error(`[stage2] wiki source watermark unavailable (${decision.warning}); enqueueing the wiki run anyway`);
-                }
-                if (!decision.enqueue || decision.payload === null) {
-                    routesLogger.info(`[stage2] wiki skipped: ${decision.reason} - same owner date and source watermark already completed`);
-                    return { status: 'skipped', reason: decision.reason };
-                }
-                // Non-forced continuity runs dedupe on the typed source snapshot (owner
-                // date + watermark) so boot/hourly/event against an unchanged snapshot
-                // resolve to ONE open workorder; a null watermark falls back to a coarse
-                // per-day hour bucket; a forced manual run stays occurrence-unique.
-                const idempotencyKey = opts?.forced
-                    ? (0, workorder_publishers_js_1.wikiBatchKey)(trigger, now)
-                    : decision.payload.sourceWatermark === null
-                        ? (0, workorder_publishers_js_1.wikiUnavailableKey)(decision.payload.ownerDate, now)
-                        : (0, workorder_publishers_js_1.wikiContinuityKey)(decision.payload.ownerDate, decision.payload.sourceWatermark);
-                const wo = enqueueWorkOrderOrThrow('wiki', idempotencyKey, { ...decision.payload }, opts?.forced ? 'high' : undefined);
-                return { status: 'enqueued', workOrderId: wo.id };
-            }
-            catch (err) {
-                const error = err instanceof Error ? err.message : String(err);
-                routesLogger.error('[stage2] wiki enqueue failed:', error);
-                return { status: 'error', error };
-            }
-        };
-        // Stage-2 wiki completion hook (plan E4): outcome reading only - the
-        // wiki:compiled events flow through the wikiPublisher independently.
-        if (workOrderConsumer) {
-            const { buildWikiAfterHook, buildWorkerTraceQueries, LANE_OBLIGATED_TOOLS } = await import('../../operator/workorder-hooks.js');
-            // Bound to the ATTEMPT: a delegated wiki attempt stays open for up to 30 minutes, and
-            // a sibling wiki order's wiki_publish must not discharge it (review P1-1).
-            const wikiTracesFor = (attemptId) => buildWorkerTraceQueries(sessionsDb, 'worker:wiki', LANE_OBLIGATED_TOOLS.wiki, attemptId);
-            workOrderConsumer.registerHook('wiki', {
-                verdictRequired: true,
-                // The trace rowid before the run is what makes the count run-bound; without it the
-                // hook would count any wiki_publish this process ever made.
-                before: (wo) => wikiTracesFor(wo.id).getTraceMaxId(),
-                after: buildWikiAfterHook((line) => routesLogger.info(line), {
-                    tracesFor: wikiTracesFor,
-                    onUnverified: (note) => eventBus.emit({
-                        type: 'agent:action',
-                        agent: 'Wiki Agent',
-                        action: 'unverified',
-                        target: note,
-                    }),
-                }),
-            });
-        }
-        // Event-driven: compile when extraction completes. Trailing-edge debounce so
-        // bursts of extraction:completed events coalesce into one wiki compile run.
-        // Scheduled/event callers discard the run outcome - their failures are
-        // log-only inside runWikiAgent; only the manual route surfaces an error.
-        eventBus.onDebounced('extraction:completed', () => {
-            runWikiAgent('extraction:completed');
-        }, 30_000);
-        // Promotion feeds the wiki: freshly promoted decisions are exactly the
-        // material daily notes and lessons compile from.
-        eventBus.onDebounced('memory:promoted', () => {
-            runWikiAgent('memory:promoted');
-        }, 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,
-                    });
-                }
-            }
-        });
-        // Manual trigger API. A manual request bypasses the skip gate (forced) and
-        // may backfill a missed recent day via a STRICT optional ownerDate; a
-        // malformed date is rejected rather than silently defaulted.
-        apiServer.app.post('/api/wiki/compile', auth_middleware_js_1.requireAuth, async (req, res) => {
-            const body = (req.body ?? {});
-            let ownerDate;
-            if (body.ownerDate !== undefined) {
-                if (typeof body.ownerDate !== 'string') {
-                    res.status(400).json({ ok: false, error: 'ownerDate must be a YYYY-MM-DD string' });
-                    return;
-                }
-                try {
-                    ownerDate = (0, wiki_continuity_js_1.parseStrictOwnerDate)(body.ownerDate);
-                }
-                catch (err) {
-                    res
-                        .status(400)
-                        .json({ ok: false, error: err instanceof Error ? err.message : String(err) });
-                    return;
-                }
-                // A future day cannot be backfilled: reject at the HTTP boundary with a
-                // clear 400 rather than letting the planner throw into a swallowed 200.
-                const currentOwnerDate = (0, wiki_continuity_js_1.ownerDateForInstant)(Date.now(), wikiTimeZone);
-                if (ownerDate > currentOwnerDate) {
-                    res.status(400).json({
-                        ok: false,
-                        error: `ownerDate ${ownerDate} is in the future (current owner date ${currentOwnerDate})`,
-                    });
-                    return;
-                }
-            }
-            const outcome = runWikiAgent('manual', { forced: true, ownerDate });
-            if (outcome.status === 'error') {
-                // A real planning/ledger/validation/enqueue failure must not be reported
-                // as success (M1): return a non-2xx and never say enqueued.
-                res.status(500).json({ ok: false, error: outcome.error });
-                return;
-            }
-            res.json({ ok: true, message: 'Wiki compile workorder enqueued', status: outcome.status });
-        });
-        // No boot enqueue (owner decision 2026-09-09): a restart is not evidence
-        // that the wiki has anything to compile, and the boot continuity order was
-        // what put a multi-minute maintenance turn in front of the owner's first
-        // message after every restart. The hourly continuity tick below still gives
-        // a new owner date its one run, on evidence rather than on boot.
-        // Host-owned hourly continuity tick. The cheap watermark/date gate inside
-        // runWikiAgent skips the model when the same owner date and source watermark
-        // already completed; a new owner date still gets one run even when quiet.
-        const WIKI_CONTINUITY_INTERVAL_MS = 60 * 60 * 1000;
-        wikiContinuityInterval = setInterval(() => {
-            runWikiAgent('hourly');
-        }, WIKI_CONTINUITY_INTERVAL_MS);
-        wikiContinuityInterval.unref?.();
-        routesLogger.info('[Wiki Agent] Ready — triggers: hourly continuity tick, extraction:completed / memory:promoted events, 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 = (0, workorder_publishers_js_1.normalizePromotionIntervalMs)(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
-        // Promotion runs are workorders: enqueue-only, the consumer lane runs
-        // them under the memory-curation brief. The PROMOTED <n> parse and its
-        // event emissions live in the completion hook below.
-        const runMemoryPromotion = (opts) => {
-            try {
-                const now = Date.now();
-                enqueueWorkOrderOrThrow('memory-curation', opts?.manual ? (0, workorder_publishers_js_1.promotionManualKey)(now) : (0, workorder_publishers_js_1.promotionKey)(now, PROMOTION_INTERVAL_MS), { scheduledAt: new Date(now).toISOString() }, opts?.manual ? 'high' : undefined);
-            }
-            catch (err) {
-                routesLogger.error('[stage2] promotion enqueue failed:', err instanceof Error ? err.message : err);
-            }
-        };
-        // Stage-2 promotion completion hook (plan E4): the PROMOTED <n> parse and
-        // its event emissions are the wiki ingress chain's second link - losing
-        // them in the workorder conversion would silently sever memory:promoted.
-        if (workOrderConsumer) {
-            const { buildPromotionAfterHook, buildWorkerTraceQueries, LANE_OBLIGATED_TOOLS, LANE_WRITE_TOOLS, } = await import('../../operator/workorder-hooks.js');
-            const promotionTracesFor = (attemptId) => buildWorkerTraceQueries(sessionsDb, 'worker:memory-curation', LANE_OBLIGATED_TOOLS['memory-curation'], attemptId);
-            workOrderConsumer.registerHook('memory-curation', {
-                before: (wo) => promotionTracesFor(wo.id).getTraceMaxId(),
-                after: buildPromotionAfterHook({
-                    emitAgentAction: (action, target) => eventBus.emit({ type: 'agent:action', agent: 'Memory Agent', action, target }),
-                    emitMemoryPromoted: (saved) => eventBus.emit({ type: 'memory:promoted', saved }),
-                    log: (line) => console.log(line),
-                }, {
-                    tracesFor: promotionTracesFor,
-                    writeTracesFor: (attemptId) => buildWorkerTraceQueries(sessionsDb, 'worker:memory-curation', LANE_WRITE_TOOLS['memory-curation'], attemptId),
-                    log: (line) => console.log(line),
-                    onUnverified: (note) => eventBus.emit({
-                        type: 'agent:action',
-                        agent: 'Memory Agent',
-                        action: 'unverified',
-                        target: note,
-                    }),
-                }),
-            });
-        }
-        setTimeout(() => runMemoryPromotion(), PROMOTION_INITIAL_DELAY_MS);
-        (0, leg_cadence_js_1.getLegCadence)()?.declare('memory-promotion', PROMOTION_INTERVAL_MS);
-        setInterval(() => {
-            (0, leg_cadence_js_1.getLegCadence)()?.beat('memory-promotion');
-            runMemoryPromotion();
-        }, PROMOTION_INTERVAL_MS);
-        apiServer.app.post('/api/memory/promote', auth_middleware_js_1.requireAuth, (_req, res) => {
-            runMemoryPromotion({ manual: true });
-            res.json({ ok: true, message: 'Memory promotion workorder enqueued' });
-        });
-        console.log(`[Memory Promotion] Ready: every ${PROMOTION_INTERVAL_MS / 3_600_000}h, POST /api/memory/promote`);
-    }
-    // -- System Audit: hourly deterministic code checks ---------------------
-    // Owner decision 2026-04-22 (legacy id: 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
-    const doSystemAudit = async () => {
-        try {
-            const report = await (0, code_audit_js_1.runCodeAudit)({
-                config: {
-                    telegram: config.telegram,
-                    multi_agent: config.multi_agent,
-                    roles: config.roles,
-                },
-                // 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 },
-                    });
-                },
-            });
-            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) {
-            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(() => {
-        void runSystemAudit();
-        (0, leg_cadence_js_1.getLegCadence)()?.declare('system-audit', AUDIT_INTERVAL_MS);
-        setInterval(() => {
-            (0, leg_cadence_js_1.getLegCadence)()?.beat('system-audit');
-            void runSystemAudit();
-        }, AUDIT_INTERVAL_MS);
-    }, AUDIT_INITIAL_DELAY_MS);
-    // Manual trigger returns the full report (read-only, no LLM, fast)
-    apiServer.app.post('/api/system/audit', auth_middleware_js_1.requireAuth, async (_req, res) => {
-        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('[System Audit] Ready - deterministic code checks every 60 min, POST /api/system/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();
-        res.json(stats);
-    });
-    // ── Memory Agent dashboard API ────────────────────────────────────────
-    apiServer.app.get('/api/memory-agent/dashboard', auth_middleware_js_1.requireAuth, async (_req, res) => {
-        try {
-            // 1. Memory agent runtime stats
-            const agentStats = messageRouter.getMemoryAgentStats();
-            // 2. Memory DB stats (decisions, checkpoints, outcomes, topics)
-            const adapter = getAdapter();
-            const now = Date.now();
-            const weekAgo = now - 7 * 24 * 60 * 60 * 1000;
-            const monthAgo = now - 30 * 24 * 60 * 60 * 1000;
-            const totalRow = adapter.prepare('SELECT COUNT(*) as count FROM decisions').get();
-            const weekRow = adapter
-                .prepare('SELECT COUNT(*) as count FROM decisions WHERE created_at > ?')
-                .get(weekAgo);
-            const monthRow = adapter
-                .prepare('SELECT COUNT(*) as count FROM decisions WHERE created_at > ?')
-                .get(monthAgo);
-            const checkpointRow = adapter.prepare('SELECT COUNT(*) as count FROM checkpoints').get();
-            const outcomeRows = adapter
-                .prepare(`SELECT outcome, COUNT(*) as count FROM decisions
-           WHERE outcome IS NOT NULL GROUP BY outcome`)
-                .all();
-            const outcomes = {};
-            for (const row of outcomeRows) {
-                outcomes[row.outcome?.toLowerCase() ?? 'unknown'] = row.count;
-            }
-            const topTopics = adapter
-                .prepare(`SELECT topic, COUNT(*) as count FROM decisions
-           WHERE topic IS NOT NULL GROUP BY topic ORDER BY count DESC LIMIT 10`)
-                .all();
-            // 3. Recent decisions (last 20)
-            const recentDecisions = adapter
-                .prepare(`SELECT id, topic, decision, outcome, confidence, created_at
-           FROM decisions ORDER BY created_at DESC LIMIT 20`)
-                .all();
-            // 4. Channel summaries (from channel_summary_state table, if it exists)
-            let channelSummaries = [];
-            try {
-                const rawSummaries = adapter
-                    .prepare('SELECT channel_key, updated_at FROM channel_summary_state ORDER BY updated_at DESC LIMIT 20')
-                    .all();
-                channelSummaries = rawSummaries.map((r) => ({
-                    channelKey: r.channel_key,
-                    updatedAt: r.updated_at,
-                }));
-            }
-            catch {
-                // Table may not exist yet — not an error
-            }
-            const payload = (0, memory_agent_dashboard_js_1.buildMemoryAgentDashboardPayload)({
-                agentStats,
-                channelSummaries,
-                recentDecisions,
-                generatedAt: new Date().toISOString(),
-            });
-            res.json({
-                ...payload,
-                agent: agentStats,
-                memory: {
-                    total: totalRow?.count ?? 0,
-                    thisWeek: weekRow?.count ?? 0,
-                    thisMonth: monthRow?.count ?? 0,
-                    checkpoints: checkpointRow?.count ?? 0,
-                    outcomes,
-                    topTopics,
-                },
-                channelSummaries,
-            });
-        }
-        catch (error) {
-            routesLogger.error('[memory-agent/dashboard] Error', error instanceof Error ? error : String(error));
-            res.status(500).json({
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    });
-    // ── Session API endpoints ─────────────────────────────────────────────
-    apiServer.app.get('/api/sessions/last-active', auth_middleware_js_1.requireAuth, async (_req, res) => {
-        try {
-            const sessions = messageRouter.listSessions('viewer');
-            if (sessions.length === 0) {
-                res.json({ session: null });
-                return;
-            }
-            const sorted = sessions.sort((a, b) => b.lastActive - a.lastActive);
-            res.json({ session: sorted[0] });
-        }
-        catch (error) {
-            console.error('[Sessions API] Error:', error);
-            res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
-        }
-    });
-    apiServer.app.get('/api/sessions', auth_middleware_js_1.requireAuth, async (_req, res) => {
-        try {
-            const viewerSessions = messageRouter.listSessions('viewer');
-            const discordSessions = messageRouter.listSessions('discord');
-            const telegramSessions = messageRouter.listSessions('telegram');
-            const slackSessions = messageRouter.listSessions('slack');
-            res.json({
-                viewer: viewerSessions,
-                discord: discordSessions,
-                telegram: telegramSessions,
-                slack: slackSessions,
-            });
-        }
-        catch (error) {
-            console.error('[Sessions API] Error:', error);
-            res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
-        }
-    });
-    registerKagemushaTaskRoute(apiServer.app, apiServer.privateConnectorPolicy);
-    // ── Agent Notices endpoint ────────────────────────────────────────────
-    apiServer.app.get('/api/agent-notices', auth_middleware_js_1.requireAuth, async (_req, res) => {
-        try {
-            const limit = Number(_req.query.limit) || 20;
-            const notices = eventBus.getRecentNotices(limit);
-            res.json({
-                success: true,
-                notices: notices.map((n) => ({
-                    agent: n.agent,
-                    action: n.action,
-                    target: n.target,
-                    timestamp: new Date(n.timestamp).toISOString(),
-                })),
-                total: notices.length,
-            });
-        }
-        catch (error) {
-            res.status(500).json({
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    });
-    // ── Discord send endpoint ─────────────────────────────────────────────
-    apiServer.app.post('/api/discord/send', auth_middleware_js_1.requireAuth, async (req, res) => {
-        try {
-            const { channelId, message } = req.body;
-            if (!channelId || !message) {
-                res.status(400).json({ error: 'channelId and message are required' });
-                return;
-            }
-            if (!discordGateway) {
-                res.status(503).json({ error: 'Discord gateway not connected' });
-                return;
-            }
-            console.log(`[Discord Send] Sending to ${channelId}: ${message.substring(0, 50)}...`);
-            await discordGateway.sendMessage(channelId, message);
-            console.log(`[Discord Send] Success`);
-            res.json({ success: true });
-        }
-        catch (error) {
-            console.error('[Discord Send] Error:', error);
-            res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
-        }
-    });
-    // ── Slack send endpoint ───────────────────────────────────────────────
-    apiServer.app.post('/api/slack/send', auth_middleware_js_1.requireAuth, async (req, res) => {
-        try {
-            const { channelId, message, filePath, caption } = req.body;
-            if (!channelId || (!message && !filePath)) {
-                res.status(400).json({ error: 'channelId and (message or filePath) are required' });
-                return;
-            }
-            if (!slackGateway) {
-                res.status(503).json({ error: 'Slack gateway not connected' });
-                return;
-            }
-            if (filePath) {
-                // SECURITY: Path traversal prevention (same pattern as /api/discord/image)
-                const fsMod = await import('fs/promises');
-                const workspacePath = config.workspace?.path?.replace('~', process.env.HOME || '') ||
-                    `${process.env.HOME}/.mama/workspace`;
-                const tempPath = node_path_1.default.join(workspacePath, 'temp');
-                const tmpPath = '/tmp';
-                const resolvedFilePath = node_path_1.default.isAbsolute(filePath)
-                    ? node_path_1.default.resolve(filePath)
-                    : node_path_1.default.resolve(workspacePath, filePath);
-                const normalizedWorkspace = node_path_1.default.resolve(workspacePath);
-                const normalizedTemp = node_path_1.default.resolve(tempPath);
-                const isInWorkspace = resolvedFilePath.startsWith(normalizedWorkspace + node_path_1.default.sep);
-                const isInTemp = resolvedFilePath.startsWith(normalizedTemp + node_path_1.default.sep);
-                const isInTmp = resolvedFilePath.startsWith(tmpPath + '/');
-                if (!isInWorkspace && !isInTemp && !isInTmp) {
-                    console.warn(`[Slack Send] SECURITY: Path traversal blocked: ${filePath} -> ${resolvedFilePath}`);
-                    res
-                        .status(400)
-                        .json({ error: 'File path must be within workspace, workspace/temp, or /tmp' });
-                    return;
-                }
-                // Block sensitive file types
-                const deniedExtensions = ['.db', '.key', '.pem', '.env', '.sqlite', '.sqlite3'];
-                const ext = node_path_1.default.extname(resolvedFilePath).toLowerCase();
-                if (deniedExtensions.includes(ext)) {
-                    console.warn(`[Slack Send] SECURITY: Denied file type blocked: ${ext}`);
-                    res.status(400).json({ error: 'File type not allowed' });
-                    return;
-                }
-                try {
-                    await fsMod.access(resolvedFilePath);
-                }
-                catch {
-                    res.status(404).json({ error: 'File not found' });
-                    return;
-                }
-                console.log(`[Slack Send] Sending file to ${channelId}: ${resolvedFilePath}`);
-                await slackGateway.sendFile(channelId, resolvedFilePath, caption);
-            }
-            if (message) {
-                console.log(`[Slack Send] Sending to ${channelId}: ${message.substring(0, 50)}...`);
-                await slackGateway.sendMessage(channelId, message);
-            }
-            console.log(`[Slack Send] Success`);
-            res.json({ success: true });
-        }
-        catch (error) {
-            console.error('[Slack Send] Error:', error);
-            res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
-        }
-    });
-    // Legacy model-and-send endpoints are retired. They accepted an arbitrary
-    // destination without the delivery ledger, so retries could duplicate output.
-    for (const retiredPath of ['/api/discord/cron', '/api/report']) {
-        apiServer.app.post(retiredPath, auth_middleware_js_1.requireAuth, (_req, res) => {
-            res.status(410).json({
-                error: 'Legacy model-and-send endpoint retired; use the owner runtime and receipted delivery',
-            });
-        });
-    }
-    // ── Screenshot endpoint ───────────────────────────────────────────────
-    apiServer.app.post('/api/screenshot', auth_middleware_js_1.requireAuth, async (req, res) => {
-        const { spawn } = await import('child_process');
-        try {
-            const { channelId, htmlFile, caption } = req.body;
-            if (!channelId || !htmlFile) {
-                res.status(400).json({ error: 'channelId and htmlFile are required' });
-                return;
-            }
-            if (!discordGateway) {
-                res.status(503).json({ error: 'Discord gateway not connected' });
-                return;
-            }
-            const workspacePath = config.workspace?.path?.replace('~', process.env.HOME || '') ||
-                `${process.env.HOME}/.mama/workspace`;
-            // SECURITY P0: Path traversal prevention
-            if (node_path_1.default.isAbsolute(htmlFile)) {
-                res.status(400).json({ error: 'Absolute paths not allowed' });
-                return;
-            }
-            const resolvedPath = node_path_1.default.resolve(workspacePath, htmlFile);
-            const normalizedWorkspace = node_path_1.default.resolve(workspacePath);
-            if (!resolvedPath.startsWith(normalizedWorkspace + node_path_1.default.sep)) {
-                res.status(400).json({ error: 'Path traversal detected' });
-                return;
-            }
-            const fs = await import('fs/promises');
-            try {
-                await fs.access(resolvedPath);
-            }
-            catch {
-                res.status(404).json({ error: 'File not found' });
-                return;
-            }
-            const allowedExtensions = ['.html', '.htm'];
-            if (!allowedExtensions.some((ext) => resolvedPath.toLowerCase().endsWith(ext))) {
-                res.status(400).json({ error: 'Only HTML files allowed' });
-                return;
-            }
-            const htmlPath = resolvedPath;
-            const outputPath = `${workspacePath}/temp/screenshot-${Date.now()}.png`;
-            console.log(`[Screenshot] Taking screenshot of: ${htmlPath}`);
-            // SECURITY P0: never shell out. Use spawn with args to avoid injection.
-            await new Promise((resolve, reject) => {
-                const child = spawn('node', [`${workspacePath}/scripts/html-screenshot.mjs`, htmlPath, outputPath], {
-                    cwd: workspacePath,
-                    stdio: 'ignore',
-                });
-                let settled = false;
-                const timeoutId = setTimeout(() => {
-                    if (settled)
-                        return;
-                    settled = true;
-                    child.kill('SIGKILL');
-                    reject(new Error('Screenshot script timed out after 30000ms'));
-                }, 30000);
-                child.on('error', (err) => {
-                    clearTimeout(timeoutId);
-                    if (settled)
-                        return;
-                    settled = true;
-                    reject(err);
-                });
-                child.on('exit', (code, signal) => {
-                    clearTimeout(timeoutId);
-                    if (settled)
-                        return;
-                    settled = true;
-                    if (code === 0) {
-                        resolve();
-                        return;
-                    }
-                    reject(new Error(`Screenshot script failed: code=${code ?? 'null'} signal=${signal ?? 'null'}`));
-                });
-            });
-            // Send to Discord
-            console.log(`[Screenshot] Sending to Discord: ${outputPath}`);
-            await discordGateway.sendFile(channelId, outputPath, caption);
-            console.log('[Screenshot] Complete');
-            res.json({ success: true, screenshot: outputPath });
-        }
-        catch (error) {
-            console.error('[Screenshot] Error:', error);
-            res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
-        }
-    });
-    // ── Discord image endpoint (4-layer path validation) ──────────────────
-    apiServer.app.post('/api/discord/image', auth_middleware_js_1.requireAuth, async (req, res) => {
-        const fs = await import('fs/promises');
-        try {
-            const { channelId, imagePath, caption } = req.body;
-            if (!channelId || !imagePath) {
-                res.status(400).json({ error: 'channelId and imagePath are required' });
-                return;
-            }
-            if (!discordGateway) {
-                res.status(503).json({ error: 'Discord gateway not connected' });
-                return;
-            }
-            // SECURITY P0: 4-layer path validation
-            const workspacePath = config.workspace?.path?.replace('~', process.env.HOME || '') ||
-                `${process.env.HOME}/.mama/workspace`;
-            const tempPath = node_path_1.default.join(workspacePath, 'temp');
-            const tmpPath = '/tmp';
-            // Layer 1: Reject absolute paths (unless in allowed directories)
-            if (node_path_1.default.isAbsolute(imagePath)) {
-                const normalizedInput = node_path_1.default.normalize(imagePath);
-                const isInWorkspace = normalizedInput.startsWith(node_path_1.default.resolve(workspacePath) + node_path_1.default.sep);
-                const isInTemp = normalizedInput.startsWith(node_path_1.default.resolve(tempPath) + node_path_1.default.sep);
-                const isInTmp = normalizedInput.startsWith(tmpPath + node_path_1.default.sep);
-                if (!isInWorkspace && !isInTemp && !isInTmp) {
-                    console.warn(`[Discord Image] SECURITY: Absolute path blocked: ${imagePath}`);
-                    res
-                        .status(400)
-                        .json({ error: 'Absolute paths only allowed in workspace, workspace/temp, or /tmp' });
-                    return;
-                }
-            }
-            // Layer 2: Resolve and verify within allowed directories
-            const resolvedImagePath = node_path_1.default.isAbsolute(imagePath)
-                ? node_path_1.default.resolve(imagePath)
-                : node_path_1.default.resolve(workspacePath, imagePath);
-            const normalizedWorkspace = node_path_1.default.resolve(workspacePath);
-            const normalizedTemp = node_path_1.default.resolve(tempPath);
-            const isInWorkspace = resolvedImagePath.startsWith(normalizedWorkspace + node_path_1.default.sep);
-            const isInTemp = resolvedImagePath.startsWith(normalizedTemp + node_path_1.default.sep);
-            const isInTmp = resolvedImagePath.startsWith(tmpPath + node_path_1.default.sep);
-            if (!isInWorkspace && !isInTemp && !isInTmp) {
-                console.warn(`[Discord Image] SECURITY: Path traversal blocked: ${imagePath} -> ${resolvedImagePath}`);
-                res.status(400).json({ error: 'Path traversal detected' });
-                return;
-            }
-            // Layer 3: Verify file exists
-            try {
-                await fs.access(resolvedImagePath);
-            }
-            catch {
-                res.status(404).json({ error: 'Image file not found' });
-                return;
-            }
-            // Layer 4: Whitelist extensions
-            const allowedExtensions = ['.png', '.jpg', '.jpeg', '.gif', '.webp'];
-            if (!allowedExtensions.some((ext) => resolvedImagePath.toLowerCase().endsWith(ext))) {
-                console.warn(`[Discord Image] SECURITY: Invalid extension blocked: ${resolvedImagePath}`);
-                res
-                    .status(400)
-                    .json({ error: 'Only image files allowed (.png, .jpg, .jpeg, .gif, .webp)' });
-                return;
-            }
-            console.log(`[Discord Image] Sending: ${resolvedImagePath}`);
-            await discordGateway.sendFile(channelId, resolvedImagePath, caption);
-            console.log('[Discord Image] Complete');
-            res.json({ success: true });
-        }
-        catch (error) {
-            console.error('[Discord Image] Error:', error);
-            res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
-        }
-    });
-    // ── Upload / download media endpoints ─────────────────────────────────
-    apiServer.app.use('/api', (0, upload_handler_js_1.createUploadRouter)());
-    // ── Auth gate for /graph/* write endpoints ────────────────────────────
-    apiServer.app.use('/graph', (req, res, next) => {
-        const isRead = req.method === 'GET' || req.method === 'HEAD';
-        if (!isRead && !(0, auth_middleware_js_1.isAuthenticated)(req)) {
-            (0, auth_middleware_js_1.logUnauthorizedAttempt)(req);
-            res.status(401).json({
-                error: true,
-                code: 'UNAUTHORIZED',
-                message: 'Authentication required.',
-            });
-            return;
-        }
-        next();
-    });
-    // ── Graph handler middleware ───────────────────────────────────────────
-    apiServer.app.use(async (req, res, next) => {
-        const handled = await graphHandler(req, res);
-        if (!handled)
-            next();
-    });
-    // ── Session proxy middleware ───────────────────────────────────────────
-    apiServer.app.use((req, res, next) => {
-        if (req.path.startsWith('/api/session')) {
-            const bodyData = req.body ? JSON.stringify(req.body) : '';
-            const options = {
-                hostname: 'localhost',
-                port: utilities_js_1.EMBEDDING_PORT,
-                path: req.url,
-                method: req.method,
-                headers: {
-                    ...req.headers,
-                    host: `localhost:${utilities_js_1.EMBEDDING_PORT}`,
-                    'content-length': Buffer.byteLength(bodyData),
-                },
-            };
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const proxy = node_http_1.default.request(options, (proxyRes) => {
-                res.writeHead(proxyRes.statusCode, proxyRes.headers);
-                proxyRes.pipe(res, { end: true });
-            });
-            if (bodyData) {
-                proxy.write(bodyData);
-            }
-            proxy.end();
-            proxy.on('error', (error) => {
-                if (!res.headersSent) {
-                    res.status(500).json({ error: 'Failed to proxy session API', details: error.message });
-                }
-            });
-        }
-        else {
-            next();
-        }
-    });
-    console.log(`✓ Session API proxied to port ${utilities_js_1.EMBEDDING_PORT}`);
-    // ── Daemon Log API ────────────────────────────────────────────────────
-    apiServer.app.get('/api/logs/daemon', auth_middleware_js_1.requireAuth, (req, res) => {
-        const logPath = node_path_1.default.join((0, node_os_1.homedir)(), '.mama', 'logs', 'daemon.log');
-        if (!(0, node_fs_1.existsSync)(logPath)) {
-            res.status(404).json({ error: 'daemon.log not found' });
-            return;
-        }
-        try {
-            const stat = (0, node_fs_1.statSync)(logPath);
-            const since = parseInt(req.query.since, 10) || 0;
-            if (since > 0 && stat.mtimeMs <= since) {
-                res.status(304).end();
-                return;
-            }
-            const requestedTail = parseInt(req.query.tail, 10);
-            const tail = Math.min(Math.max(isNaN(requestedTail) ? 200 : requestedTail, 1), 5000);
-            const chunkSize = Math.min(stat.size, tail * 300);
-            const buffer = Buffer.alloc(chunkSize);
-            const fd = (0, node_fs_1.openSync)(logPath, 'r');
-            try {
-                (0, node_fs_1.readSync)(fd, buffer, 0, chunkSize, Math.max(0, stat.size - chunkSize));
-            }
-            finally {
-                (0, node_fs_1.closeSync)(fd);
-            }
-            const raw = buffer.toString('utf-8');
-            const allLines = raw.split('\n').filter((l) => l.trim());
-            const lines = allLines.slice(-tail);
-            const isFullFile = chunkSize >= stat.size;
-            res.json({
-                lines,
-                total: isFullFile ? allLines.length : undefined,
-                totalBytes: stat.size,
-                mtime: stat.mtimeMs,
-                truncated: !isFullFile,
-            });
-        }
-        catch (err) {
-            res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
-        }
-    });
-    // ── Workspace skills API ──────────────────────────────────────────────
-    const skillsWorkDir = node_path_1.default.join((0, node_os_1.homedir)(), '.mama', 'workspace', 'skills');
-    apiServer.app.get('/api/workspace/skills', auth_middleware_js_1.requireAuth, (_req, res) => {
-        try {
-            if (!(0, node_fs_1.existsSync)(skillsWorkDir)) {
-                res.json({ skills: [] });
-                return;
-            }
-            const dirs = (0, node_fs_1.readdirSync)(skillsWorkDir, { withFileTypes: true })
-                .filter((d) => d.isDirectory())
-                .map((d) => {
-                const mdPath = node_path_1.default.join(skillsWorkDir, d.name, 'SKILL.md');
-                const exists = (0, node_fs_1.existsSync)(mdPath);
-                return { id: d.name, exists };
-            })
-                .filter((s) => s.exists)
-                .map(({ id }) => ({ id }));
-            res.json({ skills: dirs });
-        }
-        catch (err) {
-            console.warn('[GET /api/workspace/skills] Failed to read skills directory (non-fatal):', err);
-            res.json({ skills: [] });
-        }
-    });
-    apiServer.app.get('/api/workspace/skills/:name/content', auth_middleware_js_1.requireAuth, (req, res) => {
-        const name = req.params.name;
-        if (!name || /[^a-zA-Z0-9_-]/.test(name)) {
-            res.status(400).json({ error: 'Invalid skill name' });
-            return;
-        }
-        const mdPath = node_path_1.default.join(skillsWorkDir, name, 'SKILL.md');
-        try {
-            if (!(0, node_fs_1.existsSync)(mdPath)) {
-                res.status(404).json({ error: 'Skill not found' });
-                return;
-            }
-            const content = (0, node_fs_1.readFileSync)(mdPath, 'utf-8');
-            res.json({ content });
-        }
-        catch (err) {
-            routesLogger.warn('[GET /api/workspace/skills/:name/content] Failed to read skill:', err);
-            res.status(500).json({ error: 'Failed to read skill content' });
-        }
-    });
-    console.log('✓ Workspace Skills API available at /api/workspace/skills');
-    // ── Viewer static assets ──────────────────────────────────────────────
-    const publicDir = node_path_1.default.join(__dirname, '..', '..', '..', 'public');
-    apiServer.app.use(express_1.default.static(publicDir, {
-        setHeaders: (res, _filePath) => {
-            res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
-            res.setHeader('Pragma', 'no-cache');
-            res.setHeader('Expires', '0');
-        },
-    }));
-    console.log('✓ Viewer UI available at /viewer');
-    return {
-        boardReconcileEnabled,
-        requestBoardRepair,
-        stop: () => {
-            if (boardBootTimeout)
-                clearTimeout(boardBootTimeout);
-            boardBootTimeout = null;
-            if (boardInterval)
-                clearInterval(boardInterval);
-            boardInterval = null;
-            if (wikiContinuityInterval)
-                clearInterval(wikiContinuityInterval);
-            wikiContinuityInterval = null;
-            boardReconcileScheduler?.stop();
-            boardReconcileScheduler = null;
-        },
-    };
-}
-//# sourceMappingURL=api-routes-init.js.map