reflectt-node 0.1.21 → 0.1.22

package/dist/server.js

@@ -12,6 +12,8 @@ import { promises as fs, existsSync, readFileSync, readdirSync } from 'fs';
 import { resolve, sep, join } from 'path';
 import { execSync } from 'child_process';
 import { serverConfig, openclawConfig, isDev, REFLECTT_HOME, DATA_DIR } from './config.js';
+import { getStallDetector, emitWorkflowStall, onStallEvent } from './stall-detector.js';
+import { processStallEvent } from './intervention-template.js';
 import { trackRequest, getRequestMetrics } from './request-tracker.js';
 import { getPreflightMetrics, snapshotDailyMetrics, getDailySnapshots, startAutoSnapshot } from './alert-preflight.js';
 // ── Build info (read once at startup) ──────────────────────────────────────
@@ -325,6 +327,7 @@ const UpdateTaskSchema = z.object({
     assignee: z.string().optional(),
     reviewer: z.string().optional(),
     done_criteria: z.array(z.string().min(1)).optional(),
+    criteria_verified: z.boolean().optional(), // bypass done_criteria gate for todo→validating
     priority: z.enum(['P0', 'P1', 'P2', 'P3']).optional(),
     blocked_by: z.array(z.string()).optional(),
     epic_id: z.string().optional(),
@@ -2435,6 +2438,82 @@ export async function createServer() {
     // Start self-keepalive to prevent container eviction in serverless environments
     const serverPort = Number(process.env['PORT'] || process.env['REFLECTT_PORT'] || 4445);
     startSelfKeepalive(serverPort);
+    // ── Stall Detector ─────────────────────────────────────────────────────────
+    const sd = getStallDetector();
+    // Register stall event handler: compile intervention and post to chat
+    onStallEvent((event) => {
+        // Adapt stall-detector event to intervention-template expected format
+        const adaptedEvent = {
+            stallId: event.stallId,
+            userId: event.userId,
+            stallType: event.stallType,
+            personalizations: {
+                user_name: event.userId,
+                last_intent: event.context?.lastAction,
+                active_task_title: event.context?.lastAction,
+                last_agent_name: event.context?.lastAgent,
+            },
+            timestamp: event.timestamp,
+        };
+        const result = processStallEvent(adaptedEvent);
+        if (!result.sent) {
+            console.debug('[StallDetector] Intervention not sent:', result.reason);
+            return;
+        }
+        // Select an agent to send the intervention (use lastAgent from context, or default)
+        const agentName = event.context?.lastAgent || 'rhythm';
+        const message = result.message || 'Hey! Just checking in — want to pick up where you left off?';
+        // Post to #general as the intervening agent
+        const baseUrl = `http://127.0.0.1:${serverPort}`;
+        fetch(`${baseUrl}/chat/messages`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', 'x-reflectt-internal': 'true' },
+            body: JSON.stringify({ from: agentName, channel: 'general', content: message }),
+        }).catch((err) => console.error('[StallDetector] Failed to post intervention:', err));
+    });
+    // Start stall detector if enabled in config
+    const stallConfig = serverConfig.stallDetector;
+    if (stallConfig?.enabled)
+        sd.start();
+    app.get('/stall-detector', async () => {
+        return {
+            enabled: sd.getAllStates().length > 0,
+            states: sd.getAllStates().map(s => ({
+                userId: s.userId,
+                phase: s.phase,
+                context: s.context,
+                stallFired: [...s.stallFired],
+            })),
+        };
+    });
+    app.post('/stall-detector/config', async (request) => {
+        const body = (request.body ?? {});
+        // Accept: { enabled, thresholds: { newUserMinutes, inSessionMinutes, setupMinutes } }
+        const newCfg = {};
+        if (typeof body.enabled === 'boolean') {
+            newCfg.enabled = body.enabled;
+        }
+        if (body.thresholds && typeof body.thresholds === 'object') {
+            newCfg.thresholds = body.thresholds;
+        }
+        // Merge into serverConfig
+        ;
+        serverConfig.stallDetector = {
+            ...(serverConfig.stallDetector ?? {}),
+            ...newCfg,
+        };
+        if (newCfg.enabled)
+            sd.start();
+        return { success: true, config: serverConfig.stallDetector };
+    });
+    app.post('/stall-detector/test', async (request) => {
+        // Fire a test stall event for a given userId
+        const { userId } = (request.body ?? {});
+        if (!userId)
+            return { success: false, error: 'userId required' };
+        sd.recordActivity(userId, { phase: 'new_user' });
+        return { success: true, message: `Recorded activity for ${userId}` };
+    });
     // Self-keepalive status + warm boot info
     app.get('/health/keepalive', async () => {
         return getSelfKeepaliveStatus();
@@ -3549,6 +3628,8 @@ export async function createServer() {
         if (data.from) {
             presenceManager.recordActivity(data.from, 'message');
             presenceManager.touchPresence(data.from);
+            // Stall detector: user sent a message — record activity
+            getStallDetector().recordActivity(data.from);
             // Activation funnel: first team message
             emitActivationEvent('first_team_message_sent', data.from, {
                 channel: data.channel || 'general',
@@ -7984,7 +8065,8 @@ export async function createServer() {
                     'in-progress': ['blocked', 'validating', 'done', 'doing', 'todo', 'cancelled'], // legacy, permissive
                 };
                 const allowed = ALLOWED_TRANSITIONS[existing.status] ?? [];
-                if (!allowed.includes(parsed.status)) {
+                // Allow todo→validating when criteria_verified=true
+                if (!allowed.includes(parsed.status) && !(parsed.status === 'validating' && existing.status === 'todo' && parsed.criteria_verified === true)) {
                     const meta = (incomingMeta ?? {});
                     const isReopen = meta.reopen === true;
                     const reopenReason = typeof meta.reopen_reason === 'string' ? String(meta.reopen_reason).trim() : '';
@@ -8004,6 +8086,21 @@ export async function createServer() {
                     mergedMeta.reopen_reason = reopenReason;
                     mergedMeta.reopened_at = Date.now();
                     mergedMeta.reopened_from = existing.status;
+                    // ── Done-criteria verification gate ──
+                    // Block todo→validating unless criteria_verified=true is set.
+                    if (parsed.status === 'validating' && existing.status === 'todo') {
+                        const hasDoneCriteria = Boolean(existing.done_criteria && existing.done_criteria.length > 0);
+                        if (hasDoneCriteria && parsed.criteria_verified !== true) {
+                            const dc = Array.isArray(existing.done_criteria) ? existing.done_criteria.length : 0;
+                            reply.code(422);
+                            return {
+                                success: false,
+                                error: `All ${dc} done criteria must be verified. Set criteria_verified=true in PATCH body to unblock.`,
+                                code: 'DONE_CRITERIA_NOT_VERIFIED',
+                                gate: 'done_criteria_verification',
+                            };
+                        }
+                    }
                     // Emit trust signal: forced state bypass
                     const NORMAL_ESCALATION_PATHS = ['todo→doing', 'doing→validating', 'validating→done'];
                     const jumpPath = `${existing.status}→${parsed.status}`;
@@ -8495,6 +8592,19 @@ export async function createServer() {
                 reply.code(404);
                 return { success: false, error: 'Task not found' };
             }
+            // ── Emit workflow stall when task enters review ──
+            if (effectiveTargetStatus === 'validating' &&
+                existing.status !== 'validating' &&
+                existing.status !== 'done') {
+                const reviewer = task.reviewer;
+                if (reviewer) {
+                    emitWorkflowStall(reviewer, 'review_pending', {
+                        lastAction: `task "${task.title}" submitted for review`,
+                        lastAgent: task.assignee || 'unknown',
+                        lastActionAt: Date.now(),
+                    });
+                }
+            }
             // ── Audit ledger: log review-field mutations ──
             {
                 const oldMeta = (existing.metadata || {});
@@ -8549,6 +8659,10 @@ export async function createServer() {
                 if (parsed.status === 'done') {
                     presenceManager.recordActivity(task.assignee, 'task_completed');
                     presenceManager.updatePresence(task.assignee, 'working', null);
+                    // Stall detector: agent completed a task — user should respond
+                    // Determine who to notify: the task creator / assignee who might be waiting
+                    const waitingUserId = task.metadata?.userId || task.assignee;
+                    getStallDetector().recordAgentResponse(waitingUserId, task.assignee);
                     trackTaskEvent('completed');
                 }
                 else if (parsed.status === 'doing') {
@@ -10137,11 +10251,13 @@ export async function createServer() {
     // ── 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");
+    const { canvasInteractiveRoutes, registerCapabilityRoutes } = await import("./canvas-interactive.js");
     await app.register(canvasInteractiveRoutes, {
         eventBus,
         canvasStateMap,
     });
+    // Register capability routes: GET/POST /canvas/capability
+    registerCapabilityRoutes(app);
     // ── Canvas activity stream — SSE with backfill ────────────────────────
     // New viewers get the last 20 canvas events immediately on connect (backfill),
     // then receive live events going forward. Canvas feels alive from frame 1.
@@ -10314,6 +10430,7 @@ export async function createServer() {
     await app.register(canvasPushRoutes, {
         eventBus,
         queueCanvasPushEvent,
+        canvasStateMap,
     });
     // 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.
@@ -10359,6 +10476,28 @@ export async function createServer() {
             }
             catch { /* non-blocking */ }
         };
+        let canvasMetaCache = null;
+        const getCanvasMeta = () => {
+            const now = Date.now();
+            if (canvasMetaCache && (now - canvasMetaCache.age) < 30_000)
+                return canvasMetaCache;
+            const focus = getFocus();
+            let upcomingEvents = [];
+            try {
+                const events = calendarEvents.listEvents({ from: now, to: now + 24 * 60 * 60 * 1000, limit: 5 });
+                upcomingEvents = events.map(e => ({ id: e.id, summary: e.summary, dtstart: e.dtstart, organizer: e.organizer }));
+            }
+            catch { /* skip */ }
+            let recentActivity = [];
+            try {
+                const twoHoursAgo = now - 2 * 60 * 60 * 1000;
+                const activity = queryActivity({ range: '24h', type: ['task', 'chat'], limit: 10 });
+                recentActivity = activity.events.filter(e => e.ts_ms > twoHoursAgo).slice(0, 5).map(e => ({ ts: e.ts_ms, type: e.type, subject: e.subject }));
+            }
+            catch { /* skip */ }
+            canvasMetaCache = { focus, upcomingEvents, recentActivity, age: now };
+            return canvasMetaCache;
+        };
         const emitTick = () => {
             if (closed)
                 return;
@@ -10411,10 +10550,12 @@ export async function createServer() {
                     break;
                 }
             }
+            // Include focus, calendar, and activity (cached, 30s TTL)
+            const meta = getCanvasMeta();
             const tick = {
                 t: now,
                 agents,
-                team: { rhythm, tension, ambientPulse, dominantColor },
+                team: { rhythm, tension, ambientPulse, dominantColor, ...meta },
             };
             try {
                 reply.raw.write(`data: ${JSON.stringify(tick)}\n\n`);