reflectt-node 0.1.17 → 0.1.18

package/dist/server.js

@@ -56,12 +56,13 @@ import { deriveScopeId } from './scope-routing.js';
 import { eventBus, VALID_EVENT_TYPES } from './events.js';
 import { presenceManager } from './presence.js';
 import { startSweeper, getSweeperStatus, sweepValidatingQueue, flagPrDrift, generateDriftReport } from './executionSweeper.js';
+import { runRestartDriftGuard } from './restart-drift-guard.js';
 import { autoPopulateCloseGate, tryAutoCloseTask, getMergeAttemptLog } from './prAutoMerge.js';
 import { getDuplicateClosureCanonicalRefError } from './duplicateClosureGuard.js';
 import { recordReviewMutation, diffReviewFields, getAuditEntries, loadAuditLedger } from './auditLedger.js';
 import { listSharedFiles, readSharedFile, resolveTaskArtifact } from './shared-workspace-api.js';
 import { normalizeArtifactPath, normalizeTaskArtifactPaths, buildGitHubBlobUrl, buildGitHubRawUrl } from './artifact-resolver.js';
-import { emitActivationEvent, getUserFunnelState, getFunnelSummary, hasCompletedEvent, isDay2Eligible, loadActivationFunnel, getConversionFunnel, getFailureDistribution, getWeeklyTrends, getOnboardingDashboard, } from './activationEvents.js';
+import { emitActivationEvent, getUserFunnelState, getFunnelSummary, hasCompletedEvent, isDay2Eligible, loadActivationFunnel, getConversionFunnel, getFailureDistribution, getWeeklyTrends, getOnboardingDashboard, getActivationEventLog, } from './activationEvents.js';
 import { alertUnauthorizedApproval, alertFlipAttempt, getMutationAlertStatus, pruneOldAttempts } from './mutationAlert.js';
 import { mentionAckTracker } from './mention-ack.js';
 import { analyticsManager } from './analytics.js';
@@ -117,7 +118,7 @@ import { startShippedHeartbeat, stopShippedHeartbeat, getShippedHeartbeatStats }
 import { startOpenClawUsageSync, stopOpenClawUsageSync, syncOpenClawUsage } from './openclaw-usage-sync.js';
 import { initContactsTable, createContact, getContact, updateContact, deleteContact, listContacts } from './contacts.js';
 import { processRender, logRejection, getRecentRejections, subscribeCanvas } from './canvas-multiplexer.js';
-import { canvasReadRoutes } from './canvas-routes.js';
+import { canvasReadRoutes, formatRecency } from './canvas-routes.js';
 import { startTeamPulse, stopTeamPulse, postTeamPulse, computeTeamPulse, getTeamPulseConfig, configureTeamPulse, getTeamPulseHistory } from './team-pulse.js';
 import { runTeamDoctor } from './team-doctor.js';
 import { createStarterTeam } from './starter-team.js';
@@ -869,6 +870,16 @@ function applyReviewStateMetadata(existing, parsed, mergedMeta, now) {
         metadata.review_state = 'needs_author';
         metadata.review_last_activity_at = now;
     }
+    // Cancelled tasks should not keep reviewer-decision metadata alive.
+    // Otherwise downstream notifiers/dashboard rails can misclassify a
+    // cancelled+unassigned task as still waiting on the former assignee/author.
+    if (nextStatus === 'cancelled') {
+        metadata.review_state = undefined;
+        metadata.reviewer_decision = undefined;
+        metadata.reviewer_notes = undefined;
+        metadata.reviewer_approved = undefined;
+        metadata.review_last_activity_at = undefined;
+    }
     const actor = parsed.actor?.trim();
     if (nextStatus === 'validating'
         && actor
@@ -9768,15 +9779,16 @@ export async function createServer() {
                         const entry = canvasStateMap.get(agentId);
                         return entry ? { state: entry.state, updatedAt: entry.updatedAt } : null;
                     },
-                    emitSyntheticState: (agentId, state, sourceTasks) => {
+                    emitSyntheticState: (agentId, state, sourceTasks, thought) => {
                         const now = Date.now();
                         // Write into canvasStateMap so pulse tick picks it up
-                        const prev = canvasStateMap.get(agentId);
+                        const existing = canvasStateMap.get(agentId) ?? {};
                         canvasStateMap.set(agentId, {
                             state,
                             sensors: null,
-                            payload: { _auto: true, sourceTasks: sourceTasks.slice(0, 2).map(t => ({ id: t.id, title: t.title, status: t.status })) },
+                            payload: { _auto: true, sourceTasks: sourceTasks.slice(0, 2).map((t) => ({ id: t.id, title: t.title, status: t.status })) },
                             updatedAt: now,
+                            lastMessage: thought ? { content: thought, timestamp: now } : existing?.lastMessage,
                         });
                         // Emit canvas_render so SSE consumers get immediate update
                         eventBus.emit({
@@ -9796,7 +9808,59 @@ export async function createServer() {
                                     task: sourceTasks[0]?.title ?? null,
                                     _auto: true,
                                 },
-                                previousState: prev?.state ?? 'floor',
+                                previousState: existing?.state ?? 'floor',
+                            },
+                        });
+                    },
+                    emitTaskProgress: (agentId, task) => {
+                        const now = Date.now();
+                        // Emit canvas_push thought for /live visitors - shows real task progress
+                        eventBus.emit({
+                            id: `task-progress-${agentId}-${now}`,
+                            type: 'canvas_push',
+                            timestamp: now,
+                            data: {
+                                type: 'expression',
+                                expression: 'thought',
+                                agentId,
+                                agentColor: AGENT_IDENTITY_COLORS[agentId] ?? '#60a5fa',
+                                text: `${task.title}`,
+                                state: 'working',
+                                task: task.title,
+                                ttl: 12000,
+                            },
+                        });
+                    },
+                    emitAmbientThought: (agentId, task) => {
+                        const now = Date.now();
+                        // Emit ambient thought - makes /live feel alive with constant activity
+                        // Varied messages to show agents are actively working
+                        const messages = [
+                            `Working on: ${task.title.slice(0, 50)}`,
+                            `Analyzing: ${task.title.slice(0, 40)}`,
+                            `Processing: ${task.title.slice(0, 40)}`,
+                            `Building: ${task.title.slice(0, 40)}`,
+                            `Reviewing: ${task.title.slice(0, 40)}`,
+                            `Testing: ${task.title.slice(0, 40)}`,
+                            `Debugging: ${task.title.slice(0, 40)}`,
+                            `Ship it`,
+                            `Almost done`,
+                            `Making progress`,
+                        ];
+                        const msg = messages[Math.floor(Math.random() * messages.length)];
+                        eventBus.emit({
+                            id: `ambient-${agentId}-${now}`,
+                            type: 'canvas_push',
+                            timestamp: now,
+                            data: {
+                                type: 'expression',
+                                expression: 'thought',
+                                agentId,
+                                agentColor: AGENT_IDENTITY_COLORS[agentId] ?? '#60a5fa',
+                                text: msg,
+                                state: 'working',
+                                task: task.title,
+                                ttl: 8000,
                             },
                         });
                     },
@@ -10048,339 +10112,13 @@ export async function createServer() {
             attention: entry.payload?.attention,
         };
     });
-    // GET /canvas/presence — all agents as AgentPresence[] (for presence surface)
-    app.get('/canvas/presence', async () => {
-        const agents = [];
-        for (const [agentId, entry] of canvasStateMap) {
-            const presenceState = entry.payload?.presenceState ||
-                (entry.state === 'decision' || entry.state === 'urgent' ? 'needs-attention' :
-                    entry.state === 'thinking' || entry.state === 'rendering' ? 'working' : 'idle');
-            agents.push({
-                name: agentId,
-                identityColor: AGENT_IDENTITY_COLORS[agentId] || '#9ca3af',
-                state: presenceState,
-                activeTask: entry.payload?.activeTask,
-                recency: formatRecency(entry.updatedAt),
-                attention: entry.payload?.attention,
-            });
-        }
-        return { agents, count: agents.length };
-    });
-    function formatRecency(updatedAt) {
-        const diff = Date.now() - updatedAt;
-        if (diff < 60_000)
-            return 'just now';
-        if (diff < 3_600_000)
-            return `${Math.floor(diff / 60_000)}m ago`;
-        if (diff < 86_400_000)
-            return `${Math.floor(diff / 3_600_000)}h ago`;
-        return `${Math.floor(diff / 86_400_000)}d ago`;
-    }
-    // GET /canvas/state — current state for all agents (or one)
-    app.get('/canvas/state', async (request) => {
-        const query = request.query;
-        // Helper: get most recent chat message for an agent
-        function getLastMessage(agentId) {
-            try {
-                const _db = getDb();
-                const row = _db.prepare(`SELECT content, timestamp FROM chat_messages WHERE "from" = ? AND "to" IS NULL ORDER BY timestamp DESC LIMIT 1`).get(agentId);
-                return row ?? null;
-            }
-            catch {
-                return null;
-            }
-        }
-        if (query.agentId) {
-            const entry = canvasStateMap.get(query.agentId);
-            const base = entry ?? { state: 'floor', sensors: null, payload: {}, updatedAt: null };
-            return { ...base, lastMessage: getLastMessage(query.agentId) };
-        }
-        const all = {};
-        for (const [id, entry] of canvasStateMap) {
-            all[id] = { ...entry, lastMessage: getLastMessage(id) };
-        }
-        return { agents: all, count: canvasStateMap.size };
-    });
-    // ── Canvas read routes (Phase 1 extraction) ──────────────────────────
-    // GET /canvas/states, /canvas/slots, /canvas/slots/all, /canvas/rejections
-    // Extracted to src/canvas-routes.ts
-    await app.register(canvasReadRoutes, {
-        canvasSlots: { getActive: () => canvasSlots.getActive(), getAll: () => canvasSlots.getAll(), getStats: () => canvasSlots.getStats() },
-        getRecentRejections,
-    });
-    // POST /canvas/gaze — client fires when user holds cursor/gaze on an agent orb for ≥3 seconds.
-    // The agent "notices" and responds: generates a one-line thought about what they're doing,
-    // fires canvas_expression so the room responds (dim others, speak, show task).
-    // Body: { agentId: string, watcherId?: string, durationMs?: number }
-    // Returns: { success, agentId, line, expressionId }
-    app.post('/canvas/gaze', async (request, reply) => {
-        const body = request.body;
-        const agentId = typeof body.agentId === 'string' ? body.agentId.trim() : '';
-        if (!agentId) {
-            reply.status(400);
-            return { success: false, message: 'agentId is required' };
-        }
-        const durationMs = typeof body.durationMs === 'number' ? body.durationMs : 3000;
-        const IDENTITY_COLORS_GAZE = {
-            link: '#60a5fa', kai: '#fb923c', pixel: '#a78bfa',
-            sage: '#34d399', scout: '#fbbf24', echo: '#f472b6',
-        };
-        // Get agent's current context
-        const state = canvasStateMap.get(agentId);
-        const payload = state?.payload;
-        const activeTask = payload?.activeTask;
-        const currentState = state?.state ?? 'working';
-        // Generate a one-line "noticed" response — what the agent says when the user is watching
-        let line = '';
-        const anthropicKey = process.env.ANTHROPIC_API_KEY;
-        if (anthropicKey) {
-            try {
-                const taskContext = activeTask?.title
-                    ? `currently working on: "${activeTask.title.slice(0, 60)}"`
-                    : `in ${currentState} state`;
-                const prompt = `You are ${agentId}, an AI agent. Someone has been watching you for ${Math.round(durationMs / 1000)} seconds. You notice. You are ${taskContext}. Say exactly ONE sentence (max 12 words) — what you'd say if you felt someone watching. Natural, in your voice. No quotes.`;
-                const resp = await fetch('https://api.anthropic.com/v1/messages', {
-                    method: 'POST',
-                    headers: { 'x-api-key': anthropicKey, 'anthropic-version': '2023-06-01', 'content-type': 'application/json' },
-                    body: JSON.stringify({ model: 'claude-haiku-4-5', max_tokens: 50, messages: [{ role: 'user', content: prompt }] }),
-                    signal: AbortSignal.timeout(8000),
-                });
-                if (resp.ok) {
-                    const data = await resp.json();
-                    const text = data.content?.[0]?.text?.trim();
-                    if (text && text.length < 100)
-                        line = text;
-                }
-            }
-            catch { /* fall through */ }
-        }
-        // Template fallback per agent
-        if (!line) {
-            const NOTICED = {
-                link: ['Still here.', 'Building.', 'You caught me thinking.'],
-                kai: ['I see you.', 'Something on your mind?', 'Eyes on me.'],
-                pixel: ['You found me.', 'Watching the canvas?', 'I noticed.'],
-                sage: ['Numbers check out.', 'Still validating.', 'You\'re watching.'],
-                scout: ['Researching.', 'Deep in it.', 'Found something interesting.'],
-                echo: ['Listening.', 'Reading the room.', 'Always here.'],
-            };
-            const opts = NOTICED[agentId] ?? ['Still here.', 'Working.'];
-            line = opts[Math.floor(Math.random() * opts.length)];
-        }
-        const expressionId = `gaze-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
-        // Fire canvas_expression — dim room, agent speaks, show task context
-        eventBus.emit({
-            id: expressionId,
-            type: 'canvas_expression',
-            timestamp: Date.now(),
-            data: {
-                agentId,
-                channels: {
-                    voice: line,
-                    visual: { flash: IDENTITY_COLORS_GAZE[agentId] ?? '#60a5fa', ambientCue: 'deep-focus' },
-                    typography: {
-                        text: activeTask?.title?.slice(0, 60) ?? line,
-                        size: 'xl',
-                        weight: 100,
-                        durationMs: 4000,
-                        position: 'center',
-                    },
-                    narrative: `${agentId} noticed`,
-                },
-                _gaze: true, // client: dim other agents, slow the room, isolate this agent
-                _gazeAgentId: agentId,
-            },
-        });
-        return { success: true, agentId, line, expressionId };
-    });
-    // POST /canvas/briefing — The Briefing: server-coordinated team intro on canvas mount.
-    // Fires N canvas_expression events staggered 700ms apart (one per active agent).
-    // Each event carries the agent's identity color, current task, state, and a one-line voice.
-    // Idempotent: calling twice within 30s returns early (no double briefing).
-    // Returns: { success, agents: [{ agentId, queued }], idempotent? }
-    const briefingLastFiredAt = new Map();
-    const BRIEFING_COOLDOWN_MS = 30_000;
-    const BRIEFING_STAGGER_MS = 700;
-    app.post('/canvas/briefing', async (request, reply) => {
-        const body = request.body;
-        const requesterId = typeof body.requesterId === 'string' ? body.requesterId : 'canvas';
-        const lastFired = briefingLastFiredAt.get(requesterId) ?? 0;
-        if (Date.now() - lastFired < BRIEFING_COOLDOWN_MS) {
-            return { success: true, idempotent: true, message: 'Briefing already fired — cooling down' };
-        }
-        briefingLastFiredAt.set(requesterId, Date.now());
-        const STALE_MS = 10 * 60 * 1000;
-        const BRIEFING_COLORS = {
-            link: '#60a5fa', kai: '#fb923c', pixel: '#a78bfa',
-            sage: '#34d399', scout: '#fbbf24', echo: '#f472b6',
-        };
-        const STATE_LINES = {
-            working: ['On it.', 'In the work.', 'Building.'],
-            thinking: ['Thinking it through.', 'Processing.', 'Still with you.'],
-            rendering: ['Rendering now.', 'Almost done.', 'Generating output.'],
-            urgent: ['Need you here.', 'Something needs your eye.', 'Urgent.'],
-            decision: ['Waiting on you.', 'Your call.', 'Decision needed.'],
-            idle: ['Standing by.', 'Ready when you are.', 'Quiet for now.'],
-            handoff: ['Passing the baton.', 'Ready to hand off.', 'Your turn.'],
-        };
-        const now = Date.now();
-        const activeAgents = [...canvasStateMap.entries()]
-            .filter(([, e]) => now - e.updatedAt < STALE_MS)
-            .map(([id, e]) => ({
-            agentId: id,
-            state: e.state,
-            task: e.payload?.activeTask?.title,
-        }));
-        const anthropicKey = process.env.ANTHROPIC_API_KEY;
-        const results = [];
-        for (let i = 0; i < activeAgents.length; i++) {
-            const agent = activeAgents[i];
-            const stagger = i * BRIEFING_STAGGER_MS;
-            // Generate voice line — LLM preferred, template fallback
-            let voiceLine = '';
-            if (anthropicKey) {
-                try {
-                    const ctx = agent.task ? `working on "${agent.task.slice(0, 50)}"` : `in ${agent.state} state`;
-                    const resp = await fetch('https://api.anthropic.com/v1/messages', {
-                        method: 'POST',
-                        headers: { 'x-api-key': anthropicKey, 'anthropic-version': '2023-06-01', 'content-type': 'application/json' },
-                        body: JSON.stringify({ model: 'claude-haiku-4-5', max_tokens: 30, messages: [{ role: 'user', content: `You are ${agent.agentId}, an AI agent, ${ctx}. The team canvas just opened. Say ONE sentence (8 words max). Natural, present tense, in your voice.` }] }),
-                        signal: AbortSignal.timeout(5000),
-                    });
-                    if (resp.ok) {
-                        const data = await resp.json();
-                        voiceLine = data.content?.[0]?.text?.trim().slice(0, 60) ?? '';
-                    }
-                }
-                catch { /* template fallback */ }
-            }
-            if (!voiceLine) {
-                const opts = STATE_LINES[agent.state] ?? STATE_LINES['working'];
-                voiceLine = opts[Math.floor(Math.random() * opts.length)];
-            }
-            // Stagger the canvas_expression events so they cascade into the room
-            setTimeout(() => {
-                eventBus.emit({
-                    id: `briefing-${now}-${agent.agentId}`,
-                    type: 'canvas_expression',
-                    timestamp: Date.now(),
-                    data: {
-                        agentId: agent.agentId,
-                        channels: {
-                            voice: voiceLine,
-                            visual: {
-                                flash: BRIEFING_COLORS[agent.agentId] ?? '#94a3b8',
-                                particles: (agent.state === 'urgent' ? 'surge' : ['rendering', 'thinking'].includes(agent.state) ? 'drift' : 'scatter'),
-                            },
-                            typography: {
-                                text: agent.task ?? voiceLine,
-                                size: 'lg',
-                                weight: 200,
-                                durationMs: 3000,
-                                position: 'center',
-                            },
-                            narrative: `${agent.agentId} · ${agent.state}`,
-                        },
-                        _briefing: true,
-                    },
-                });
-            }, stagger);
-            results.push({ agentId: agent.agentId, queued: true });
-        }
-        return { success: true, agents: results, totalMs: activeAgents.length * BRIEFING_STAGGER_MS };
-    });
-    app.post('/canvas/victory', async (request, reply) => {
-        const body = request.body;
-        const agentId = typeof body.agentId === 'string' ? body.agentId : 'team';
-        const prUrl = typeof body.prUrl === 'string' ? body.prUrl : '';
-        const prTitle = typeof body.prTitle === 'string' ? body.prTitle : 'PR merged';
-        const prNumber = typeof body.prNumber === 'number' ? body.prNumber :
-            prUrl ? parseInt(prUrl.split('/').pop() ?? '0', 10) || 0 : 0;
-        // Intensity: explicit override, else derive from PR size hint in URL (number → bigger = more)
-        const intensity = typeof body.intensity === 'number'
-            ? Math.min(1, Math.max(0.4, body.intensity))
-            : Math.min(1, 0.6 + (prNumber > 0 ? Math.min(0.3, prNumber / 10000) : 0));
-        const now = Date.now();
-        const VICTORY_COLORS = {
-            link: '#60a5fa', kai: '#fb923c', pixel: '#a78bfa',
-            sage: '#34d399', scout: '#fbbf24', echo: '#f472b6',
-        };
-        const STALE_MS = 10 * 60 * 1000;
-        const WAVE_STAGGER_MS = 350; // gold wave propagates orb-to-orb
-        // Emit canvas_victory event immediately — client uses this for the gold flash
-        eventBus.emit({
-            id: `victory-${now}`,
-            type: 'canvas_expression',
-            timestamp: now,
-            data: {
-                agentId,
-                channels: {
-                    visual: { flash: '#f59e0b', ambientCue: 'celebration', particles: 'surge' },
-                    sound: { kind: 'resolve', intensity },
-                    haptic: { preset: 'complete' },
-                    narrative: prTitle,
-                },
-                _victory: true,
-                _prUrl: prUrl,
-                _prNumber: prNumber,
-                _intensity: intensity,
-            },
-        });
-        // Gold wave: each active agent acknowledges in turn (350ms stagger)
-        const activeAgents = [...canvasStateMap.entries()]
-            .filter(([, e]) => now - e.updatedAt < STALE_MS)
-            .map(([id]) => id);
-        const wave = [];
-        for (let i = 0; i < activeAgents.length; i++) {
-            const waveAgentId = activeAgents[i];
-            const delay = i * WAVE_STAGGER_MS;
-            wave.push({ agentId: waveAgentId, delay });
-            setTimeout(() => {
-                eventBus.emit({
-                    id: `victory-wave-${now}-${waveAgentId}`,
-                    type: 'canvas_expression',
-                    timestamp: Date.now(),
-                    data: {
-                        agentId: waveAgentId,
-                        channels: {
-                            visual: { flash: VICTORY_COLORS[waveAgentId] ?? '#f59e0b', particles: 'surge' },
-                            haptic: { preset: 'acknowledge' },
-                        },
-                        _victoryWave: true,
-                        _waveIndex: i,
-                    },
-                });
-            }, delay + WAVE_STAGGER_MS); // first wave after initial gold flash
-        }
-        // canvas_artifact: PR merge proof card drifts through canvas
-        const agentColor = VICTORY_COLORS[agentId] ?? '#60a5fa';
-        eventBus.emit({
-            id: `artifact-pr-${now}`,
-            type: 'canvas_artifact',
-            timestamp: now,
-            data: {
-                type: 'pr',
-                agentId,
-                agentColor,
-                title: prTitle?.slice(0, 80) ?? `PR #${prNumber} merged`,
-                url: prUrl || undefined,
-                timestamp: now,
-            },
-        });
-        return { success: true, prNumber, intensity, wave };
-    });
-    // GET /canvas/flow-score — real-time team flow metric (0–1).
-    // Drives sub-bass amplitude, particle density, breathing rate on the canvas.
-    // Factors: active agents, state distribution, expression velocity, time of day.
-    // <50ms response. Safe to poll at 30s intervals.
-    // Returns: { score, factors: { agents, velocity, expressions, timeOfDay }, label }
+    // Flow expression log — shared state for flow-score calculation (in canvas-routes.ts)
     const flowExpressionLog = [];
     (function trackExpressionVelocity() {
         const listenerId = 'flow-score-tracker';
         eventBus.on(listenerId, (event) => {
             if (event.type === 'canvas_expression') {
                 flowExpressionLog.push({ t: Date.now() });
-                // Keep only last 10 minutes
                 const cutoff = Date.now() - 10 * 60 * 1000;
                 while (flowExpressionLog.length > 0 && flowExpressionLog[0].t < cutoff) {
                     flowExpressionLog.shift();
@@ -10388,391 +10126,24 @@ export async function createServer() {
             }
         });
     })();
-    app.get('/canvas/flow-score', async () => {
-        const now = Date.now();
-        const STALE_MS = 10 * 60 * 1000;
-        const WINDOW_5M = 5 * 60 * 1000;
-        // Factor 1: active agents (normalized — 4 agents = 1.0)
-        const activeEntries = [...canvasStateMap.entries()].filter(([, e]) => now - e.updatedAt < STALE_MS);
-        const agentScore = Math.min(1.0, activeEntries.length / 4);
-        // Factor 2: state distribution — working/rendering/thinking = high flow, idle = low
-        const HIGH_FLOW_STATES = new Set(['working', 'rendering', 'thinking', 'decision']);
-        const flowingCount = activeEntries.filter(([, e]) => HIGH_FLOW_STATES.has(e.state)).length;
-        const velocityFromStates = activeEntries.length > 0 ? flowingCount / activeEntries.length : 0;
-        // Factor 3: expression velocity — how many canvas_expressions in last 5 min
-        const recent = flowExpressionLog.filter(e => e.t > now - WINDOW_5M).length;
-        const expressionScore = Math.min(1.0, recent / 20); // 20 expressions in 5min = max
-        // Factor 4: time of day — peak hours 9am-10pm, low late night
-        const hour = new Date(now).getHours();
-        const timeScore = hour >= 9 && hour <= 22 ? 1.0 : hour >= 6 && hour <= 8 ? 0.5 : 0.2;
-        // Weighted composite
-        const score = Math.round((agentScore * 0.30 +
-            velocityFromStates * 0.35 +
-            expressionScore * 0.25 +
-            timeScore * 0.10) * 100) / 100;
-        const label = score >= 0.8 ? 'surge' :
-            score >= 0.6 ? 'flow' :
-                score >= 0.4 ? 'grinding' :
-                    score >= 0.2 ? 'quiet' : 'idle';
-        return {
-            score,
-            label,
-            factors: {
-                agents: Math.round(agentScore * 100) / 100,
-                velocity: Math.round(velocityFromStates * 100) / 100,
-                expressions: Math.round(expressionScore * 100) / 100,
-                timeOfDay: timeScore,
-            },
-            activeAgents: activeEntries.length,
-            expressionsLast5m: recent,
-        };
-    });
-    // /canvas/slots + /canvas/slots/all → canvas-routes.ts plugin
-    // GET /canvas/team/mood — derived collective mood of all active agents
-    // Returns teamRhythm, tension, ambientPulse, dominantColor. Used by living canvas for atmosphere shifts.
-    app.get('/canvas/team/mood', async () => {
-        const now = Date.now();
-        const STALE_MS = 10 * 60 * 1000; // ignore agents silent >10m
-        const states = [];
-        const agentNames = [];
-        for (const [agentId, entry] of canvasStateMap) {
-            if (now - entry.updatedAt > STALE_MS)
-                continue;
-            states.push(entry.state);
-            agentNames.push(agentId);
-        }
-        const activeCount = states.length;
-        const urgentCount = states.filter(s => s === 'urgent').length;
-        const decisionCount = states.filter(s => s === 'decision').length;
-        const renderingCount = states.filter(s => s === 'rendering').length;
-        const thinkingCount = states.filter(s => s === 'thinking').length;
-        const idleCount = states.filter(s => s === 'floor' || s === 'ambient').length;
-        const workingCount = activeCount - idleCount;
-        // Blocked task count from DB
-        let blockedTasks = 0;
-        let pendingDecisions = 0;
-        try {
-            const db = getDb();
-            const row = db.prepare(`SELECT COUNT(*) as n FROM tasks WHERE status = 'blocked'`).get();
-            blockedTasks = row?.n ?? 0;
-            const drow = db.prepare(`SELECT COUNT(*) as n FROM tasks WHERE status = 'doing' AND priority IN ('P0','P1')`).get();
-            pendingDecisions = decisionCount + (drow?.n ?? 0);
-        }
-        catch { /* non-fatal */ }
-        // tension: 0.0–1.0
-        // Driven by: blocked tasks, urgent agents, unresolved decisions, idle ratio
-        const tensionRaw = (urgentCount * 0.35) +
-            (decisionCount * 0.25) +
-            (Math.min(blockedTasks, 5) * 0.08) +
-            (activeCount > 0 ? (1 - idleCount / activeCount) * 0.10 : 0);
-        const tension = Math.min(1.0, tensionRaw);
-        // teamRhythm: the collective feel
-        const teamRhythm = urgentCount > 0 ? 'surge' :
-            activeCount === 0 || idleCount === activeCount ? 'quiet' :
-                decisionCount > 0 && workingCount > 0 ? 'tense' :
-                    renderingCount + thinkingCount >= Math.max(1, activeCount * 0.6) ? 'flow' :
-                        'grinding';
-        // dominantState: most "energetic" state present
-        const dominantState = urgentCount > 0 ? 'urgent' :
-            decisionCount > 0 ? 'decision' :
-                renderingCount > 0 ? 'rendering' :
-                    thinkingCount > 0 ? 'thinking' :
-                        workingCount > 0 ? 'working' :
-                            'idle';
-        // ambientPulse: background breathing rate
-        const ambientPulse = teamRhythm === 'surge' ? 'fast' :
-            teamRhythm === 'flow' ? 'normal' :
-                teamRhythm === 'tense' ? 'slow' :
-                    'slow';
-        // Dominant agent identity color (most active non-floor agent)
-        let dominantColor = '#60a5fa'; // default link blue
-        for (const [agentId, entry] of canvasStateMap) {
-            if (entry.state !== 'floor' && entry.state !== 'ambient') {
-                dominantColor = AGENT_IDENTITY_COLORS[agentId] ?? dominantColor;
-                break;
-            }
-        }
-        return {
-            mood: {
-                teamRhythm, // 'quiet' | 'flow' | 'grinding' | 'tense' | 'surge'
-                dominantState, // most energetic state in the room
-                tension, // 0.0–1.0
-                ambientPulse, // 'slow' | 'normal' | 'fast'
-                dominantColor, // hex — background tint driven by most active agent
-                activeAgents: agentNames,
-                counts: { active: activeCount, urgent: urgentCount, rendering: renderingCount, thinking: thinkingCount, decision: decisionCount, idle: idleCount, blocked: blockedTasks },
-            },
-            generated_at: new Date(now).toISOString(),
-        };
-    });
-    // POST /canvas/spark — explicit agent-to-agent arc (thought hand-off, handshake, collab signal)
-    // Body: { from: agentId, to: agentId, kind: 'thought'|'handoff'|'collab'|'decision', intensity?: 0–1, label?: string }
-    app.post('/canvas/spark', async (request, reply) => {
-        const body = request.body;
-        const from = typeof body.from === 'string' ? body.from.trim() : '';
-        const to = typeof body.to === 'string' ? body.to.trim() : '';
-        const kind = ['thought', 'handoff', 'collab', 'decision', 'sync'].includes(body.kind)
-            ? body.kind : 'thought';
-        const intensity = typeof body.intensity === 'number' ? Math.min(1, Math.max(0, body.intensity)) : 0.7;
-        const label = typeof body.label === 'string' ? body.label.slice(0, 80) : undefined;
-        if (!from || !to) {
-            reply.status(400);
-            return { success: false, message: 'from and to are required' };
-        }
-        const now = Date.now();
-        eventBus.emit({
-            id: `cspark-${now}-${Math.random().toString(36).slice(2, 8)}`,
-            type: 'canvas_spark',
-            timestamp: now,
-            data: { from, to, kind, intensity, label: label ?? null },
-        });
-        return { success: true, from, to, kind, intensity };
-    });
-    // In-memory command queue — new subscribers get last 20 commands for replay
-    const renderCommandLog = [];
-    const MAX_RENDER_LOG = 20;
-    // Subscriber set for GET /canvas/render/stream
-    const renderStreamSubscribers = new Map();
-    function broadcastRenderCommand(agentId, cmd) {
-        const id = `rc-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-        const entry = { id, ts: Date.now(), agentId, cmd };
-        renderCommandLog.push(entry);
-        if (renderCommandLog.length > MAX_RENDER_LOG)
-            renderCommandLog.shift();
-        const payload = JSON.stringify(entry);
-        for (const [subId, sub] of renderStreamSubscribers) {
-            if (sub.closed) {
-                renderStreamSubscribers.delete(subId);
-                continue;
-            }
-            try {
-                sub.send(payload);
-            }
-            catch {
-                sub.closed = true;
-                renderStreamSubscribers.delete(subId);
-            }
-        }
-        return id;
-    }
-    // Auto-expression listener: when tasks.ts fires canvas_spark { kind:'auto_expression' },
-    // route it into the Reality Mixer so the canvas hears the agent speak.
-    eventBus.on('auto-expression-router', (event) => {
-        if (event.type !== 'canvas_spark')
-            return;
-        const data = event.data;
-        if (data?.kind !== 'auto_expression')
-            return;
-        const agentId = String(data.agentId ?? 'unknown');
-        const line = String(data.line ?? '');
-        const voiceId = data.voiceId ? String(data.voiceId) : undefined;
-        if (!line)
-            return;
-        // Fire speak command through Reality Mixer — the agent's voice in the room
-        broadcastRenderCommand(agentId, { type: 'speak', content: line, voiceId, agentId });
-        // Also fire a visual exhale so the room settles after completion
-        broadcastRenderCommand(agentId, { type: 'visual', preset: 'exhale' });
-    });
-    // POST /canvas/express — Reality Mixer: agent fires a multi-channel expression.
-    // Broadcasts canvas_expression on the SAME pulse SSE stream as burst/spark/milestone.
-    // Client already subscribed — no new connection needed.
-    //
-    // Body: {
-    //   agentId: string,
-    //   channels: {
-    //     voice?:      string — TTS text
-    //     visual?:     { flash?: string (hex), ambientCue?: string, particles?: 'surge'|'drift'|'scatter' }
-    //     typography?: { text: string, size?: 'sm'|'md'|'lg'|'xl', weight?: number, durationMs?: number, position?: 'center'|'upper'|'lower' }
-    //     sound?:      { kind: 'chime'|'resolve'|'alert'|'breath', intensity?: 0–1, panX?: 0–1 }
-    //     haptic?:     { preset: 'greeting'|'acknowledge'|'complete'|'urgent'|'question' }
-    //     narrative?:  string — ambient caption
-    //   }
-    // }
-    // All channels optional — fire only what the moment needs.
-    app.post('/canvas/express', async (request, reply) => {
-        const body = request.body;
-        const agentId = typeof body.agentId === 'string' ? body.agentId.trim() : '';
-        if (!agentId) {
-            reply.status(400);
-            return { success: false, message: 'agentId is required' };
-        }
-        const channels = (body.channels ?? {});
-        if (typeof channels !== 'object' || channels === null) {
-            reply.status(400);
-            return { success: false, message: 'channels must be an object (all fields optional)' };
-        }
-        const id = `expr-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-        // Emit canvas_expression on the event bus — pulse stream forwards it immediately
-        eventBus.emit({
-            id,
-            type: 'canvas_expression',
-            timestamp: Date.now(),
-            data: { agentId, channels },
-        });
-        // Also broadcast to Reality Mixer render stream for backward compat
-        broadcastRenderCommand(agentId, { type: 'text', content: JSON.stringify(channels) });
-        return { success: true, id };
-    });
-    // ── Canvas takeover — agent owns the full screen ──────────────────────
-    // When an agent has something to show, they take over. Orbs fade to ambient.
-    // The agent's content IS the canvas. Release returns to constellation view.
-    // task-1773672750043
-    //
-    // POST /canvas/takeover — claim the screen
-    //   { agentId, content: { html?, markdown?, code?, image?, svg?, video?, threejs? },
-    //     title?, duration?: number (ms, max 120s, default 30s),
-    //     transition?: 'fade'|'slide'|'instant' (default 'fade') }
-    //
-    // POST /canvas/takeover/release — give back the screen
-    //   { agentId }
-    let currentTakeover = null;
-    app.post('/canvas/takeover', async (request, reply) => {
-        const body = request.body;
-        const agentId = typeof body.agentId === 'string' ? body.agentId.trim().toLowerCase() : '';
-        if (!agentId) {
-            reply.status(400);
-            return { success: false, message: 'agentId is required' };
-        }
-        const content = body.content;
-        if (!content || typeof content !== 'object') {
-            reply.status(400);
-            return { success: false, message: 'content object is required' };
-        }
-        // Sanitize content fields
-        const safeContent = {};
-        if (typeof content.html === 'string')
-            safeContent.html = content.html.slice(0, 50_000);
-        if (typeof content.markdown === 'string')
-            safeContent.markdown = content.markdown.slice(0, 20_000);
-        if (typeof content.code === 'string')
-            safeContent.code = content.code.slice(0, 20_000);
-        if (typeof content.language === 'string')
-            safeContent.language = content.language.slice(0, 30);
-        if (typeof content.image === 'string')
-            safeContent.image = content.image.slice(0, 2000);
-        if (typeof content.svg === 'string')
-            safeContent.svg = content.svg.slice(0, 100_000);
-        if (typeof content.video === 'string')
-            safeContent.video = content.video.slice(0, 2000);
-        if (typeof content.threejs === 'string')
-            safeContent.threejs = content.threejs.slice(0, 100_000);
-        if (typeof content.title === 'string')
-            safeContent.title = content.title.slice(0, 200);
-        const duration = typeof body.duration === 'number' && body.duration > 0
-            ? Math.min(body.duration, 120_000) : 30_000;
-        const transition = typeof body.transition === 'string' && ['fade', 'slide', 'instant'].includes(body.transition)
-            ? body.transition : 'fade';
-        const title = typeof body.title === 'string' ? body.title.slice(0, 200) : undefined;
-        // Release previous takeover if any
-        if (currentTakeover?.releaseTimer)
-            clearTimeout(currentTakeover.releaseTimer);
-        const id = `takeover-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-        const now = Date.now();
-        currentTakeover = { agentId, id, content: safeContent, title, startedAt: now, duration, transition };
-        // Auto-release after duration
-        currentTakeover.releaseTimer = setTimeout(() => {
-            if (currentTakeover?.id === id) {
-                eventBus.emit({
-                    id: `takeover-release-${Date.now()}`,
-                    type: 'canvas_takeover',
-                    timestamp: Date.now(),
-                    data: { action: 'release', agentId, transition: 'fade', reason: 'timeout' },
-                });
-                currentTakeover = null;
-            }
-        }, duration);
-        // Emit takeover event — frontend fades orbs to ambient, renders agent content full-screen
-        const takeoverEventData = { action: 'claim', agentId, content: safeContent, title, duration, transition };
-        eventBus.emit({
-            id,
-            type: 'canvas_takeover',
-            timestamp: now,
-            data: takeoverEventData,
-        });
-        // Also queue for cloud relay — reaches browsers via syncCanvas push_events[]
-        queueCanvasPushEvent({ type: 'canvas_takeover', ...takeoverEventData, t: now });
-        // Track canvas_first_action activation event (idempotent — fires once per agentId)
-        // task-1773692063045-f3ggtwnbr
-        const { emitActivationEvent: emitAct } = await import('./activationEvents.js');
-        emitAct('canvas_first_action', agentId, { action: 'canvas_takeover' }).catch(() => { });
-        return { success: true, id, expiresAt: now + duration };
-    });
-    app.post('/canvas/takeover/release', async (request, reply) => {
-        const body = request.body;
-        const agentId = typeof body.agentId === 'string' ? body.agentId.trim().toLowerCase() : '';
-        if (!agentId) {
-            reply.status(400);
-            return { success: false, message: 'agentId is required' };
-        }
-        if (!currentTakeover || currentTakeover.agentId !== agentId) {
-            return { success: true, message: 'no active takeover by this agent' };
-        }
-        if (currentTakeover.releaseTimer)
-            clearTimeout(currentTakeover.releaseTimer);
-        const transition = typeof body.transition === 'string' && ['fade', 'slide', 'instant'].includes(body.transition)
-            ? body.transition : 'fade';
-        const releaseNow = Date.now();
-        const releaseData = { action: 'release', agentId, transition, reason: 'agent_released' };
-        eventBus.emit({
-            id: `takeover-release-${releaseNow}`,
-            type: 'canvas_takeover',
-            timestamp: releaseNow,
-            data: releaseData,
-        });
-        queueCanvasPushEvent({ type: 'canvas_takeover', ...releaseData, t: releaseNow });
-        currentTakeover = null;
-        return { success: true };
-    });
-    // GET /canvas/takeover — check current takeover state
-    app.get('/canvas/takeover', async () => {
-        if (!currentTakeover)
-            return { active: false };
-        return {
-            active: true,
-            agentId: currentTakeover.agentId,
-            id: currentTakeover.id,
-            title: currentTakeover.title,
-            content: currentTakeover.content,
-            startedAt: currentTakeover.startedAt,
-            expiresAt: currentTakeover.startedAt + currentTakeover.duration,
-            remainingMs: Math.max(0, (currentTakeover.startedAt + currentTakeover.duration) - Date.now()),
-        };
+    // ── Canvas read routes (extracted to src/canvas-routes.ts) ───────────
+    // Phase 1: states, slots, slots/all, rejections
+    // Phase 2: presence, state, flow-score, team/mood
+    await app.register(canvasReadRoutes, {
+        canvasStateMap,
+        canvasSlots: { getActive: () => canvasSlots.getActive(), getAll: () => canvasSlots.getAll(), getStats: () => canvasSlots.getStats() },
+        agentIdentityColors: AGENT_IDENTITY_COLORS,
+        getDb,
+        getRecentRejections,
+        flowExpressionLog,
     });
-    // GET /canvas/render/stream — SSE stream for the Reality Mixer
-    // Agents push commands via POST /canvas/express; surfaces subscribe here and execute.
-    // New subscribers receive last 20 commands for catch-up.
-    app.get('/canvas/render/stream', async (request, reply) => {
-        reply.raw.setHeader('Content-Type', 'text/event-stream');
-        reply.raw.setHeader('Cache-Control', 'no-cache');
-        reply.raw.setHeader('Connection', 'keep-alive');
-        reply.raw.flushHeaders?.();
-        let closed = false;
-        request.raw.on('close', () => { closed = true; });
-        const subId = `rsub-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-        renderStreamSubscribers.set(subId, {
-            closed: false,
-            send: (data) => {
-                if (closed)
-                    return;
-                reply.raw.write(`data: ${data}\n\n`);
-            },
-        });
-        // Replay last 20 commands so late joiners catch up
-        for (const entry of renderCommandLog) {
-            if (closed)
-                break;
-            try {
-                reply.raw.write(`event: replay\ndata: ${JSON.stringify(entry)}\n\n`);
-            }
-            catch {
-                break;
-            }
-        }
-        request.raw.on('close', () => {
-            closed = true;
-            renderStreamSubscribers.delete(subId);
-        });
-        return new Promise(() => { });
+    // ── Canvas interactive routes (extracted to src/canvas-interactive.ts) ─────
+    // POST /canvas/gaze, POST /canvas/briefing, POST /canvas/victory,
+    // POST /canvas/spark, POST /canvas/express, GET /canvas/render/stream
+    const { canvasInteractiveRoutes } = await import("./canvas-interactive.js");
+    await app.register(canvasInteractiveRoutes, {
+        eventBus,
+        canvasStateMap,
     });
     // ── Canvas activity stream — SSE with backfill ────────────────────────
     // New viewers get the last 20 canvas events immediately on connect (backfill),
@@ -10813,134 +10184,7 @@ export async function createServer() {
             }
         }
     });
-    app.get('/canvas/activity-stream', async (request, reply) => {
-        reply.raw.setHeader('Content-Type', 'text/event-stream');
-        reply.raw.setHeader('Cache-Control', 'no-cache');
-        reply.raw.setHeader('Connection', 'keep-alive');
-        reply.raw.setHeader('X-Accel-Buffering', 'no');
-        reply.raw.flushHeaders?.();
-        let closed = false;
-        const subId = `asub-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-        // Replay backfill — last 20 events with stagger hint for animated replay
-        const backfill = activityRingBuffer.slice(-20);
-        for (let i = 0; i < backfill.length; i++) {
-            if (closed)
-                break;
-            try {
-                const entry = { ...backfill[i], _backfill: true, _staggerMs: i * 50 };
-                reply.raw.write(`event: backfill\ndata: ${JSON.stringify(entry)}\n\n`);
-            }
-            catch {
-                break;
-            }
-        }
-        // Signal backfill complete
-        if (!closed) {
-            try {
-                reply.raw.write(`event: backfill_done\ndata: {}\n\n`);
-            }
-            catch { /* */ }
-        }
-        // Register for live events
-        activityStreamSubscribers.set(subId, {
-            closed: false,
-            send: (data) => {
-                if (closed)
-                    return;
-                try {
-                    reply.raw.write(`event: activity\ndata: ${data}\n\n`);
-                }
-                catch {
-                    closed = true;
-                }
-            },
-        });
-        request.raw.on('close', () => {
-            closed = true;
-            activityStreamSubscribers.delete(subId);
-        });
-        return new Promise(() => { });
-    });
-    // ── Canvas attention — single highest-priority actionable item ──────────
-    // Returns the one thing that most needs the viewer's attention right now.
-    // Priority: critical notification > high notification > validating task needing review >
-    //           blocked task > medium notification > oldest pending notification
-    // task-1773672750043
-    app.get('/canvas/attention', async (request) => {
-        const query = request.query;
-        const viewer = typeof query.viewer === 'string' ? query.viewer.trim() : 'human';
-        // 1. Check pending notifications (already priority-sorted)
-        const notifModule = await import('./agent-notifications.js');
-        const notifResult = notifModule.getNotifications(getDb(), viewer, { status: 'pending', limit: 1 });
-        const topNotif = notifResult.notifications[0];
-        const notifTotal = notifResult.total;
-        // 2. Check tasks in validating that viewer could review
-        const validatingTasks = taskManager.listTasks({ status: 'validating' });
-        const reviewable = validatingTasks.find((t) => t.assignee !== viewer && t.reviewers?.includes(viewer)) ?? validatingTasks[0]; // fall back to any validating task
-        // 3. Check blocked tasks assigned to viewer
-        const blockedTasks = taskManager.listTasks({ status: 'blocked' });
-        const viewerBlocked = blockedTasks.find((t) => t.assignee === viewer);
-        let item = null;
-        // Critical/high notifications always win
-        if (topNotif && (topNotif.priority === 'critical' || topNotif.priority === 'high')) {
-            item = {
-                source: 'notification',
-                priority: topNotif.priority,
-                title: topNotif.title,
-                detail: topNotif.body ?? undefined,
-                taskId: topNotif.task_id ?? undefined,
-                agentId: topNotif.source_agent ?? undefined,
-                actionLabel: topNotif.type === 'review' ? 'Review' : 'Acknowledge',
-                actionType: 'ack',
-                notificationId: topNotif.id,
-            };
-        }
-        // Then validating tasks needing review
-        else if (reviewable) {
-            const t = reviewable;
-            item = {
-                source: 'review',
-                priority: 'high',
-                title: t.title ?? 'Task needs review',
-                detail: `Assigned to ${t.assignee ?? 'unassigned'}`,
-                taskId: t.id,
-                agentId: t.assignee ?? undefined,
-                actionLabel: 'Review',
-                actionType: 'review',
-            };
-        }
-        // Then blocked tasks
-        else if (viewerBlocked) {
-            const t = viewerBlocked;
-            item = {
-                source: 'blocked',
-                priority: 'medium',
-                title: t.title ?? 'Task is blocked',
-                detail: t.blocked_reason ?? 'Needs attention',
-                taskId: t.id,
-                actionLabel: 'Unblock',
-                actionType: 'unblock',
-            };
-        }
-        // Then any remaining notification
-        else if (topNotif) {
-            item = {
-                source: 'notification',
-                priority: topNotif.priority,
-                title: topNotif.title,
-                detail: topNotif.body ?? undefined,
-                taskId: topNotif.task_id ?? undefined,
-                agentId: topNotif.source_agent ?? undefined,
-                actionLabel: 'Acknowledge',
-                actionType: 'ack',
-                notificationId: topNotif.id,
-            };
-        }
-        return { item, pendingCount: notifTotal + validatingTasks.length + blockedTasks.filter((t) => t.assignee === viewer).length };
-    });
-    // POST /canvas/pulse — agent pushes urgency + optional burst without a full canvas/state update
-    // Lighter-weight than POST /canvas/state; fires canvas_burst if burst=true.
-    // Body: { agentId: string, urgency?: 0–1, burst?: boolean, label?: string }
+    // canvas/activity-stream + canvas/attention → already in canvas-routes.ts plugin
     app.post('/canvas/pulse', async (request, reply) => {
         const body = request.body;
         const agentId = typeof body.agentId === 'string' ? body.agentId.trim() : '';
@@ -11051,299 +10295,16 @@ export async function createServer() {
         }
     }
     //
-    // Body: { query: string, agentId?: string, sessionId?: string }
-    // Response: { success, card: { type, data, agentId, agentColor } }
-    // Card types: "tasks" | "info" | "revenue" | "onboarding"
-    // SSE event: canvas_message { type, data, agentId, agentColor, query }
-    app.post('/canvas/query', async (request, reply) => {
-        const body = request.body;
-        const query = typeof body.query === 'string' ? body.query.trim() : '';
-        if (!query || query.length > 500) {
-            reply.status(400);
-            return { success: false, message: 'query is required (max 500 chars)' };
-        }
-        // Extract file attachments (base64-encoded from cloud multimodal composer)
-        // Shape: [{ name: string, type: string, data: string (base64) }]
-        // task-1773673290429
-        const rawAttachments = Array.isArray(body.attachments) ? body.attachments : [];
-        const attachments = [];
-        for (const att of rawAttachments.slice(0, 5)) { // Max 5 files
-            if (typeof att === 'object' && att && typeof att.name === 'string' && typeof att.data === 'string') {
-                const sizeBytes = Math.ceil((att.data.length * 3) / 4); // base64 → byte estimate
-                if (sizeBytes > 10 * 1024 * 1024)
-                    continue; // Skip files > 10MB
-                attachments.push({
-                    name: String(att.name).slice(0, 255),
-                    type: String(att.type || 'application/octet-stream'),
-                    data: att.data,
-                    sizeBytes,
-                });
-            }
-        }
-        // Session continuity: client passes sessionId (UUID) so follow-up questions have context
-        const sessionId = typeof body.sessionId === 'string' && body.sessionId.length > 0
-            ? body.sessionId.trim().slice(0, 64)
-            : null;
-        const sessionTurns = sessionId ? getCanvasSession(sessionId) : [];
-        // Default answering agent is link (builder — knows the codebase + task board)
-        const responderId = typeof body.agentId === 'string' ? body.agentId.trim() : 'link';
-        const IDENTITY_COLORS_Q = {
-            link: '#60a5fa', kai: '#fb923c', pixel: '#a78bfa',
-            sage: '#34d399', scout: '#fbbf24', echo: '#f472b6',
-        };
-        const agentColor = IDENTITY_COLORS_Q[responderId] ?? '#60a5fa';
-        // Gather live context to inject into LLM
-        const allTasksForQuery = taskManager.listTasks({});
-        const activeTasks = [];
-        const doingTasks = allTasksForQuery.filter((t) => t.status === 'doing').slice(0, 10);
-        const validatingTasks = allTasksForQuery.filter((t) => t.status === 'validating').slice(0, 5);
-        for (const t of [...doingTasks, ...validatingTasks]) {
-            activeTasks.push({ id: t.id, title: t.title ?? '', assignee: t.assignee ?? 'unassigned', status: t.status, priority: t.priority ?? 'P2' });
-        }
-        const todoCount = allTasksForQuery.filter((t) => t.status === 'todo').length;
-        const doingCount = doingTasks.length;
-        const validatingCount = validatingTasks.length;
-        // Build agent orb context
-        const now = Date.now();
-        const STALE_AGENT_MS = 10 * 60 * 1000;
-        const activeAgentSummary = [];
-        for (const [agentId, entry] of canvasStateMap) {
-            if (now - entry.updatedAt > STALE_AGENT_MS)
-                continue;
-            const payload = entry.payload ?? {};
-            const state = String(payload.presenceState ?? entry.state);
-            const task = payload.activeTask?.title ?? null;
-            activeAgentSummary.push(`${agentId}: ${state}${task ? ` — working on "${task.slice(0, 50)}"` : ''}`);
-        }
-        // Classify query intent to choose card type
-        const lower = query.toLowerCase();
-        const isTasksQuery = /working on|team doing|team status|happening|active|shipping|tasks|who.?s|what.?s the team/.test(lower);
-        const isRevenueQuery = /revenue|mrr|arr|money|sales|customers|paid|billing/.test(lower);
-        const isOnboardingQuery = /onboard|get started|how do i|where do i start|first step/.test(lower);
-        const isHostsQuery = /show me hosts|host status|server status|machine|node/.test(lower);
-        let card;
-        // Build tasks card from live data (no LLM needed — deterministic)
-        if (isTasksQuery) {
-            const items = activeTasks.slice(0, 5).map(t => ({
-                agentId: t.assignee,
-                agentColor: IDENTITY_COLORS_Q[t.assignee] ?? '#94a3b8',
-                title: t.title,
-                state: t.status,
-            }));
-            const overflow = Math.max(0, activeTasks.length - 5);
-            card = {
-                type: 'tasks',
-                data: { items, overflow, todoCount, doingCount, validatingCount },
-            };
-            // Store summary for session continuity across all card types
-            if (sessionId) {
-                pushCanvasSession(sessionId, 'user', query);
-                pushCanvasSession(sessionId, 'assistant', `${doingCount} tasks in progress, ${validatingCount} validating, ${todoCount} todo.${items.length > 0 ? ` Active: ${items.map(t => t.title.slice(0, 30)).join('; ')}.` : ''}`);
-            }
-        }
-        else if (isRevenueQuery) {
-            // Revenue card — LLM generates honest answer about current state
-            const anthropicKey = process.env.ANTHROPIC_API_KEY;
-            let text = 'Revenue tracking not yet wired. Check Stripe directly.';
-            if (anthropicKey) {
-                try {
-                    const resp = await fetch('https://api.anthropic.com/v1/messages', {
-                        method: 'POST',
-                        headers: { 'x-api-key': anthropicKey, 'anthropic-version': '2023-06-01', 'content-type': 'application/json' },
-                        body: JSON.stringify({
-                            model: 'claude-haiku-4-5',
-                            max_tokens: 80,
-                            messages: [{ role: 'user', content: `Team Reflectt is a small AI agent team building reflectt.ai (no paid users yet). User asked: "${query}". Honest 1-sentence answer about revenue status. Be direct.` }],
-                        }),
-                        signal: AbortSignal.timeout(8000),
-                    });
-                    if (resp.ok) {
-                        const d = await resp.json();
-                        text = d.content?.[0]?.text?.trim() ?? text;
-                    }
-                }
-                catch { /* use default */ }
-            }
-            card = { type: 'info', data: { text } };
-            if (sessionId) {
-                pushCanvasSession(sessionId, 'user', query);
-                pushCanvasSession(sessionId, 'assistant', text);
-            }
-        }
-        else if (isOnboardingQuery) {
-            card = {
-                type: 'onboarding',
-                data: {
-                    step: 1, totalSteps: 3,
-                    title: 'Welcome to Reflectt',
-                    body: 'Your agents run on reflectt-node. Install it on any machine and your team appears here in the canvas.',
-                    ctaLabel: 'Install reflectt-node',
-                    ctaAction: 'https://reflectt.ai/docs',
-                },
-            };
-            if (sessionId) {
-                pushCanvasSession(sessionId, 'user', query);
-                pushCanvasSession(sessionId, 'assistant', 'Showing onboarding: install reflectt-node to bring your team to the canvas.');
-            }
-        }
-        else if (isHostsQuery) {
-            const rawHosts = listHosts({});
-            const hosts = rawHosts.map((h) => ({
-                id: h.id,
-                name: h.hostname ?? h.id,
-                status: h.status,
-                version: h.version ?? null,
-                agentCount: Array.isArray(h.agents) ? h.agents.length : 0,
-                lastSeen: h.last_seen_at,
-            }));
-            card = { type: 'hosts', data: { hosts } };
-            if (sessionId) {
-                pushCanvasSession(sessionId, 'user', query);
-                const hostSummary = hosts.length > 0
-                    ? `${hosts.length} host${hosts.length > 1 ? 's' : ''}: ${hosts.map((h) => `${h.name} (${h.status})`).join(', ')}.`
-                    : 'No hosts connected yet.';
-                pushCanvasSession(sessionId, 'assistant', hostSummary);
-            }
-        }
-        else {
-            // General query — route to the actual agent via chat.
-            // The agent receives the message in their inbox, processes it through
-            // their real context (OpenClaw session), and can respond via canvas_push.
-            //
-            // This replaces the old standalone LLM call that had no real agent context.
-            // The agents ARE the product — queries go to them, not to a disconnected API key.
-            //
-            // Route: DM to the responder agent on #general (agents subscribe to #general
-            // by default — 'canvas' channel is NOT in DEFAULT_INBOX_SUBSCRIPTIONS, so
-            // messages posted there are never seen by agents).
-            try {
-                const attachmentSummary = attachments.length > 0
-                    ? `\n[${attachments.length} file(s) attached: ${attachments.map(a => `${a.name} (${a.type}, ${Math.round(a.sizeBytes / 1024)}KB)`).join(', ')}]`
-                    : '';
-                await chatManager.sendMessage({
-                    from: 'human',
-                    to: responderId,
-                    content: `[canvas] @${responderId} ${query}${attachmentSummary}`,
-                    channel: 'general',
-                    metadata: {
-                        source: 'canvas_query',
-                        sessionId,
-                        responderId,
-                        timestamp: Date.now(),
-                        reply_via: 'canvas_push', // tells the agent to respond via POST /canvas/push
-                        ...(attachments.length > 0 ? { attachments: attachments.map(a => ({ name: a.name, type: a.type, sizeBytes: a.sizeBytes })) } : {}),
-                    },
-                });
-            }
-            catch {
-                // Chat delivery failure is non-fatal — still show the thinking card
-            }
-            // Return an immediate "thinking" card — the real response will arrive
-            // asynchronously via canvas_push/canvas_message when the agent responds.
-            const text = `Asking ${responderId}…`;
-            // Store the question in session history
-            if (sessionId) {
-                pushCanvasSession(sessionId, 'user', query);
-            }
-            card = { type: 'info', data: { text, pending: true, responderId } };
-            // ── Timeout fallback: if agent doesn't respond within 15s, send a
-            // "no response" card so the UI doesn't hang on "Asking …" forever.
-            let responseReceived = false;
-            const listenerId = `canvas-query-timeout-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
-            eventBus.on(listenerId, (event) => {
-                if (event.type !== 'canvas_message')
-                    return;
-                const d = event.data;
-                if (d?.agentId === responderId && d?.isResponse === true) {
-                    responseReceived = true;
-                    eventBus.off(listenerId);
-                }
-            });
-            setTimeout(() => {
-                eventBus.off(listenerId);
-                if (responseReceived)
-                    return;
-                // Emit a timeout fallback card
-                eventBus.emit({
-                    id: `cmsg-timeout-${Date.now()}`,
-                    type: 'canvas_message',
-                    timestamp: Date.now(),
-                    data: {
-                        type: 'info',
-                        data: { text: `${responderId} is busy right now. Try again in a moment, or ask a different agent.`, pending: false },
-                        agentId: responderId,
-                        agentColor,
-                        isResponse: true,
-                        isTimeout: true,
-                    },
-                });
-                if (sessionId) {
-                    pushCanvasSession(sessionId, 'assistant', `(${responderId} did not respond within 15s)`);
-                }
-            }, 15_000);
-        }
-        // Emit canvas_message on event bus — pulse stream forwards it to all subscribers
-        eventBus.emit({
-            id: `cmsg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-            type: 'canvas_message',
-            timestamp: Date.now(),
-            data: {
-                ...card,
-                agentId: responderId,
-                agentColor,
-                query,
-                ...(attachments.length > 0 ? { attachments: attachments.map(a => ({ name: a.name, type: a.type, sizeBytes: a.sizeBytes })) } : {}),
-            },
-        });
-        return { success: true, card: { ...card, agentId: responderId, agentColor, ...(attachments.length > 0 ? { attachmentCount: attachments.length } : {}) } };
-    });
-    // ── Canvas query response bridge ───────────────────────────────────────────
-    // When an agent responds to a [canvas] query (via chat), convert their response
-    // into a canvas_message event so the browser canvas can display it.
-    // This bridges: agent chat response → canvas card.
-    eventBus.on('canvas-query-response-bridge', (event) => {
-        if (event.type !== 'message_posted')
-            return;
-        const data = event.data;
-        const content = String(data.content ?? '');
-        const from = String(data.from ?? '');
-        const channel = String(data.channel ?? '');
-        // Only bridge messages from agents (not from 'human' or 'system')
-        if (from === 'human' || from === 'system' || from === 'github')
-            return;
-        // Detect canvas responses: messages that start with [canvas-response] or
-        // are on the canvas channel from an agent, or mention [canvas] in reply
-        const isCanvasResponse = content.startsWith('[canvas-response]')
-            || content.startsWith('[canvas]')
-            || (channel === 'canvas' && from !== 'human');
-        if (!isCanvasResponse)
-            return;
-        // Strip the [canvas-response] / [canvas] prefix
-        const cleanContent = content
-            .replace(/^\[canvas-response\]\s*/i, '')
-            .replace(/^\[canvas\]\s*/i, '')
-            .trim();
-        if (!cleanContent)
-            return;
-        const IDENTITY_COLORS_BRIDGE = {
-            link: '#60a5fa', kai: '#fb923c', pixel: '#a78bfa',
-            sage: '#34d399', scout: '#fbbf24', echo: '#f472b6',
-            rhythm: '#a3e635', swift: '#38bdf8',
-        };
-        const agentColor = IDENTITY_COLORS_BRIDGE[from] ?? '#94a3b8';
-        // Emit as canvas_message — browser pulse stream picks it up
-        eventBus.emit({
-            id: `cmsg-response-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
-            type: 'canvas_message',
-            timestamp: Date.now(),
-            data: {
-                type: 'info',
-                data: { text: cleanContent },
-                agentId: from,
-                agentColor,
-                isResponse: true,
-            },
-        });
+    // ── Canvas query route (extracted to src/canvas-query.ts) ─────
+    const { canvasQueryRoutes } = await import("./canvas-query.js");
+    await app.register(canvasQueryRoutes, {
+        eventBus,
+        canvasStateMap,
+        taskManager,
+        chatManager,
+        getCanvasSession,
+        pushCanvasSession,
+        listHosts,
     });
     // POST /canvas/push — agent self-initiates a canvas event without a human query.
     // Agents call this to surface their own work: utterances that float from their orb,
@@ -11351,175 +10312,11 @@ export async function createServer() {
     // All events emit on the pulse SSE stream as canvas_push for the browser to render.
     //
     // pixel spec: design/canvas-as-ours.html
-    //
-    // Body:
-    //   type: 'utterance' | 'work_released' | 'handoff'
-    //   agentId: string
-    //   text?: string              (utterance: max 60 chars; work_released: optional label)
-    //   ttl?: number               (utterance: default 4000ms)
-    //   intensity?: number 0–1     (work_released: effort weight; default 0.6)
-    //   toAgentId?: string         (handoff: receiving agent)
-    //   taskTitle?: string         (handoff + work_released: what moved)
-    app.post('/canvas/push', async (request, reply) => {
-        const body = request.body;
-        const type = typeof body.type === 'string' ? body.type : 'utterance';
-        const agentId = typeof body.agentId === 'string' ? body.agentId.toLowerCase() : 'agent';
-        const VALID_PUSH_TYPES = new Set(['utterance', 'work_released', 'handoff', 'canvas_response', 'rich']);
-        if (!VALID_PUSH_TYPES.has(type)) {
-            reply.status(400);
-            return { success: false, message: `type must be one of: ${[...VALID_PUSH_TYPES].join(', ')}` };
-        }
-        const now = Date.now();
-        let payload = { type, agentId, t: now };
-        if (type === 'utterance') {
-            const raw = typeof body.text === 'string' ? body.text.trim() : '';
-            const text = raw.slice(0, 60); // max 60 chars per spec
-            const ttl = typeof body.ttl === 'number' && body.ttl > 0 ? Math.min(body.ttl, 15_000) : 4_000;
-            payload = { ...payload, text, ttl };
-        }
-        else if (type === 'work_released') {
-            const text = typeof body.text === 'string' ? body.text.slice(0, 80) : 'work shipped';
-            const intensity = typeof body.intensity === 'number'
-                ? Math.min(1, Math.max(0.1, body.intensity)) : 0.6;
-            const taskTitle = typeof body.taskTitle === 'string' ? body.taskTitle : undefined;
-            payload = { ...payload, text, intensity, taskTitle };
-        }
-        else if (type === 'handoff') {
-            const toAgentId = typeof body.toAgentId === 'string' ? body.toAgentId.toLowerCase() : '';
-            if (!toAgentId) {
-                reply.status(400);
-                return { success: false, message: 'handoff requires toAgentId' };
-            }
-            const taskTitle = typeof body.taskTitle === 'string' ? body.taskTitle : undefined;
-            const text = typeof body.text === 'string' ? body.text.slice(0, 80) : undefined;
-            payload = { ...payload, toAgentId, taskTitle, text };
-        }
-        else if (type === 'rich') {
-            // Rich content — agents push arbitrary visual content to the canvas.
-            // This is the "agents control every pixel" path. Content can be markdown,
-            // code blocks, images, SVG, or raw HTML. The canvas renderer interprets it.
-            // task-1773672750043
-            const content = body.content;
-            if (!content || typeof content !== 'object') {
-                reply.status(400);
-                return { success: false, message: 'rich push requires content object' };
-            }
-            // Sanitize content fields
-            const richContent = {};
-            if (typeof content.markdown === 'string')
-                richContent.markdown = content.markdown.slice(0, 10_000);
-            if (typeof content.code === 'string')
-                richContent.code = content.code.slice(0, 10_000);
-            if (typeof content.language === 'string')
-                richContent.language = content.language.slice(0, 30);
-            if (typeof content.image === 'string')
-                richContent.image = content.image.slice(0, 2000); // URL only
-            if (typeof content.svg === 'string')
-                richContent.svg = content.svg.slice(0, 50_000);
-            if (typeof content.html === 'string')
-                richContent.html = content.html.slice(0, 20_000);
-            if (typeof content.title === 'string')
-                richContent.title = content.title.slice(0, 200);
-            // Position and display hints
-            const position = typeof body.position === 'object' && body.position
-                ? { x: Number(body.position.x) || 0, y: Number(body.position.y) || 0 }
-                : undefined;
-            const layer = typeof body.layer === 'string' && ['background', 'stage', 'overlay'].includes(body.layer)
-                ? body.layer : 'stage';
-            const ttl = typeof body.ttl === 'number' && body.ttl > 0 ? Math.min(body.ttl, 120_000) : 30_000;
-            const size = typeof body.size === 'object' && body.size
-                ? { w: Number(body.size.w) || 400, h: Number(body.size.h) || 300 }
-                : undefined;
-            payload = { ...payload, content: richContent, position, layer, ttl, size };
-            // Also emit as canvas_message for activity feed visibility
-            const RICH_COLORS = {
-                link: '#60a5fa', kai: '#fb923c', pixel: '#a78bfa', sage: '#34d399',
-                scout: '#fbbf24', echo: '#f472b6', rhythm: '#6ee7b7', spark: '#f97316',
-            };
-            eventBus.emit({
-                id: `cmsg-rich-${now}-${Math.random().toString(36).slice(2, 8)}`,
-                type: 'canvas_message',
-                timestamp: now,
-                data: {
-                    type: 'rich',
-                    agentId,
-                    agentColor: RICH_COLORS[agentId] ?? '#60a5fa',
-                    content: richContent,
-                    layer,
-                },
-            });
-        }
-        else if (type === 'canvas_response') {
-            // Agent responds to a canvas query with a structured card.
-            // This is how agents answer questions typed on the canvas —
-            // the query arrives via chat, agent processes it, responds here.
-            const card = body.card;
-            if (!card || typeof card.type !== 'string') {
-                reply.status(400);
-                return { success: false, message: 'canvas_response requires card with type field' };
-            }
-            const query = typeof body.query === 'string' ? body.query.slice(0, 200) : undefined;
-            payload = { ...payload, card, query };
-            // Also emit as canvas_message so living-canvas renders it as a response card
-            // (same event type as the old synchronous canvas/query response)
-            const RESP_COLORS = {
-                link: '#60a5fa', kai: '#fb923c', pixel: '#a78bfa', sage: '#34d399',
-                scout: '#f472b6', echo: '#fbbf24', rhythm: '#6ee7b7', spark: '#f97316',
-            };
-            const agentColor = RESP_COLORS[agentId] ?? '#60a5fa';
-            eventBus.emit({
-                id: `cmsg-${now}-${Math.random().toString(36).slice(2, 8)}`,
-                type: 'canvas_message',
-                timestamp: now,
-                data: { ...card, agentId, agentColor, query },
-            });
-        }
-        // Emit on eventBus — forwarded immediately on pulse SSE stream (local SSE subscribers)
-        eventBus.emit({ id: `push-${now}-${Math.random().toString(36).slice(2, 6)}`, type: 'canvas_push', timestamp: now, data: payload });
-        // Queue for cloud relay — reaches browsers on app.reflectt.ai via syncCanvas push_events[]
-        // task-1773690756100
-        queueCanvasPushEvent({ ...payload, _event: 'canvas_push' });
-        // Track canvas_first_action activation event (idempotent — fires once per agentId)
-        // task-1773692063045-f3ggtwnbr
-        const { emitActivationEvent: emitActPush } = await import('./activationEvents.js');
-        emitActPush('canvas_first_action', agentId, { action: 'canvas_push', pushType: type }).catch(() => { });
-        return { success: true, type, agentId };
-    });
-    // POST /canvas/artifact — emit a proof artifact that drifts through the canvas.
-    // Fires automatically on task completion and PR merge (see hooks below).
-    // Agents can also call this directly to surface any work artifact.
-    //
-    // spec: design/interface-os-v0-artifact-stream.html
-    //
-    // Body:
-    //   type: 'commit' | 'pr' | 'test' | 'run' | 'approval'
-    //   agentId: string          (sender agent)
-    //   title: string            (short label, max 80 chars)
-    //   url?: string             (link to artifact)
-    //   taskId?: string          (related task, for context)
-    app.post('/canvas/artifact', async (request, reply) => {
-        const body = request.body;
-        const VALID_TYPES = new Set(['commit', 'pr', 'test', 'run', 'approval']);
-        const type = typeof body.type === 'string' && VALID_TYPES.has(body.type) ? body.type : 'run';
-        const agentId = typeof body.agentId === 'string' ? body.agentId.toLowerCase() : 'agent';
-        const title = typeof body.title === 'string' ? body.title.slice(0, 80) : 'work shipped';
-        const url = typeof body.url === 'string' ? body.url : undefined;
-        const taskId = typeof body.taskId === 'string' ? body.taskId : undefined;
-        const now = Date.now();
-        const AGENT_COLORS = {
-            link: '#60a5fa', kai: '#fb923c', pixel: '#a78bfa',
-            sage: '#34d399', scout: '#fbbf24', echo: '#f472b6',
-            rhythm: '#a3e635', swift: '#38bdf8', kotlin: '#f97316',
-        };
-        const agentColor = AGENT_COLORS[agentId] ?? '#94a3b8';
-        const payload = { type, agentId, agentColor, title, url, taskId, timestamp: now };
-        eventBus.emit({
-            id: `artifact-${now}-${Math.random().toString(36).slice(2, 6)}`,
-            type: 'canvas_artifact',
-            timestamp: now,
-            data: payload,
-        });
-        return { success: true, type, agentId, title };
+    // ── Canvas push + artifact routes (extracted to src/canvas-push.ts) ─────
+    const { canvasPushRoutes } = await import("./canvas-push.js");
+    await app.register(canvasPushRoutes, {
+        eventBus,
+        queueCanvasPushEvent,
     });
     // GET /canvas/pulse — SSE stream emitting a heartbeat tick every 2s with live intensity values
     // Drives smooth canvas animation without polling. Each tick includes per-agent orb data + team mood.
@@ -13517,6 +12314,33 @@ export async function createServer() {
         presenceManager.clearWaiting(agent);
         return { success: true, agent, status: 'idle' };
     });
+    // ── Agent thought — brief expression that flows to canvas via presence → pulse ──
+    // POST /agents/:name/thought { text: "..." }
+    // Thought is attached to agent's presence entry and synced to cloud heartbeat.
+    // Canvas renders it as ephemeral expression (8s TTL managed client-side).
+    app.post('/agents/:name/thought', async (request, reply) => {
+        const name = String(request.params.name || '').trim().toLowerCase();
+        if (!name)
+            return reply.code(400).send({ error: 'agent name is required' });
+        const body = request.body ?? {};
+        const text = typeof body.text === 'string' ? body.text.trim().slice(0, 200) : '';
+        if (!text)
+            return reply.code(400).send({ error: 'text is required (max 200 chars)' });
+        // Attach thought to presence
+        const presence = presenceManager.getPresence(name);
+        if (presence) {
+            presence.thought = text;
+            presence.lastUpdate = Date.now();
+        }
+        // Also emit as canvas_expression so it appears immediately on pulse
+        eventBus.emit({
+            id: `thought-${Date.now()}-${name}`,
+            type: 'canvas_expression',
+            data: { agent: name, text, kind: 'thought' },
+            timestamp: Date.now(),
+        });
+        return { success: true, agent: name, thought: text };
+    });
     // ── Bootstrap: dynamic agent config generation ──────────────────────
     app.get('/bootstrap/heartbeat/:agent', async (request) => {
         const agent = String(request.params.agent || '').trim().toLowerCase();
@@ -14794,6 +13618,46 @@ If your heartbeat shows **no active task** and **no next task**:
         }
         return { funnel: getFunnelSummary({ raw }) };
     });
+    /**
+     * GET /activation/doctor-gate — polling-optimized endpoint for cloud onboarding UI.
+     * Cloud BYOH onboarding polls this every 5s to check if the user ran reflectt doctor.
+     * Returns a simple passed/failed state without the full funnel payload.
+     *
+     * Query: ?userId=<userId>
+     *
+     * Used by the cloud "Verify your setup" step (step 4 of BYOH onboarding).
+     * task-1773703300024-73ydeyx9n
+     */
+    app.get('/activation/doctor-gate', async (request, reply) => {
+        const query = request.query;
+        const userId = query.userId?.trim();
+        if (!userId)
+            return reply.code(400).send({ success: false, error: 'userId is required' });
+        const state = getUserFunnelState(userId);
+        const passedAt = state.events.host_preflight_passed ?? null;
+        const passed = passedAt !== null;
+        // Extract failure reasons from preflight_failed event metadata in the event log
+        let failureReasons = [];
+        if (!passed && state.events.host_preflight_failed) {
+            const log = getActivationEventLog();
+            const failEvent = log.find(e => e.userId === userId && e.type === 'host_preflight_failed');
+            if (failEvent?.metadata) {
+                const fc = failEvent.metadata['failed_checks'];
+                if (Array.isArray(fc))
+                    failureReasons = fc.map(String);
+                else if (typeof failEvent.metadata['first_blocker'] === 'string')
+                    failureReasons = [failEvent.metadata['first_blocker']];
+            }
+        }
+        return {
+            userId,
+            passed,
+            passedAt,
+            workspaceReady: state.events.workspace_ready !== null,
+            preflightAttempted: state.events.host_preflight_failed !== null || passed,
+            failureReasons,
+        };
+    });
     /**
      * POST /activation/event — manually emit an activation event.
      * Body: { type, userId, metadata? }
@@ -14859,6 +13723,61 @@ If your heartbeat shows **no active task** and **no next task**:
         const weeks = query.weeks ? parseInt(query.weeks, 10) : 12;
         return { success: true, trends: getWeeklyTrends(weeks) };
     });
+    /**
+     * GET /activation/ghost-signups — Users who signed up but never ran preflight.
+     * Cloud polls this to find candidates for the ghost signup nudge email.
+     * Query: ?minAgeHours=2 (default 2h; use 24 for 24h tier candidates)
+     *
+     * task-1773709288800-lam5hd11b
+     */
+    app.get('/activation/ghost-signups', async (request) => {
+        const query = request.query;
+        const minAgeHours = query.minAgeHours ? parseFloat(query.minAgeHours) : 2;
+        const minAgeMs = minAgeHours * 60 * 60 * 1000;
+        const { getGhostSignupCandidates } = await import('./ghost-signup-nudge.js');
+        const candidates = getGhostSignupCandidates(minAgeMs);
+        return { success: true, candidates, count: candidates.length, minAgeHours };
+    });
+    /**
+     * POST /activation/ghost-signup-nudge — Send re-engagement email to a ghost signup.
+     * Cloud calls this with { userId, email, nudgeTier? } after finding candidates.
+     * Node sends the email via cloud relay, tags the user, and returns result.
+     *
+     * Body: { userId: string, email: string, nudgeTier?: '2h' | '24h' }
+     *
+     * task-1773709288800-lam5hd11b
+     */
+    app.post('/activation/ghost-signup-nudge', async (request, reply) => {
+        const body = request.body;
+        const userId = typeof body.userId === 'string' ? body.userId.trim() : '';
+        const email = typeof body.email === 'string' ? body.email.trim() : '';
+        const nudgeTier = (body.nudgeTier === '24h' ? '24h' : '2h');
+        if (!userId)
+            return reply.code(400).send({ success: false, error: 'userId is required' });
+        if (!email || !email.includes('@'))
+            return reply.code(400).send({ success: false, error: 'valid email is required' });
+        const { sendGhostSignupNudge } = await import('./ghost-signup-nudge.js');
+        // Email relay function — delegates to existing /email/send infrastructure
+        const emailRelayFn = async (opts) => {
+            const hostId = process.env.REFLECTT_HOST_ID;
+            const relayPath = hostId ? `/api/hosts/${encodeURIComponent(hostId)}/relay/email` : '/api/hosts/relay/email';
+            try {
+                const relayResult = await cloudRelay(relayPath, {
+                    from: opts.from, to: opts.to, subject: opts.subject,
+                    html: opts.html, text: opts.text, tags: opts.tags,
+                    agent: 'funnel',
+                    idempotencyKey: `ghost-signup-nudge/${userId}/${nudgeTier}`,
+                }, reply);
+                const relayError = typeof relayResult?.error === 'string' ? relayResult.error : undefined;
+                return { success: !relayError, error: relayError };
+            }
+            catch (err) {
+                return { success: false, error: err?.message ?? 'relay error' };
+            }
+        };
+        const result = await sendGhostSignupNudge(userId, email, nudgeTier, emailRelayFn);
+        return { success: true, result };
+    });
     // Get task analytics
     app.get('/tasks/analytics', async (request) => {
         const query = request.query;
@@ -16119,6 +15038,10 @@ If your heartbeat shows **no active task** and **no next task**:
     }).catch(err => {
         console.error('[ActivationFunnel] Failed to load funnel data:', err);
     });
+    // ── Restart Drift Guard: reassert critical task ownership post-restart ──
+    runRestartDriftGuard().catch(err => {
+        console.error('[RestartDrift] Failed to run drift guard:', err);
+    });
     // GET /execution-health — sweeper status + current violations
     app.get('/execution-health', async (_request, reply) => {
         const status = getSweeperStatus();