prism-mcp-server 5.2.0 → 5.5.0

package/dist/storage/sqlite.js

@@ -230,42 +230,51 @@ export class SqliteStorage {
         catch {
             // Column doesn't exist — do the table rebuild
             debugLog("[SqliteStorage] v3.0 migration: rebuilding session_handoffs with role column");
-            // Step 1: Create new table with correct constraint
-            await this.db.execute(`
-        CREATE TABLE session_handoffs_v2 (
-          id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(16)))),
-          project TEXT NOT NULL,
-          user_id TEXT NOT NULL DEFAULT 'default',
-          role TEXT NOT NULL DEFAULT 'global',
-          last_summary TEXT DEFAULT NULL,
-          pending_todo TEXT DEFAULT '[]',
-          active_decisions TEXT DEFAULT '[]',
-          keywords TEXT DEFAULT '[]',
-          key_context TEXT DEFAULT NULL,
-          active_branch TEXT DEFAULT NULL,
-          version INTEGER NOT NULL DEFAULT 1,
-          metadata TEXT DEFAULT '{}',
-          created_at TEXT DEFAULT (datetime('now')),
-          updated_at TEXT DEFAULT (datetime('now')),
-          UNIQUE(project, user_id, role)
-        )
-      `);
-            // Step 2: Copy data with explicit column names (Pro-Tip 2)
-            await this.db.execute(`
-        INSERT INTO session_handoffs_v2
-          (id, project, user_id, role, last_summary, pending_todo,
-           active_decisions, keywords, key_context, active_branch,
-           version, metadata, created_at, updated_at)
-        SELECT
-          id, project, user_id, 'global', last_summary, pending_todo,
-          active_decisions, keywords, key_context, active_branch,
-          version, metadata, created_at, updated_at
-        FROM session_handoffs
-      `);
-            // Step 3: Drop old and rename
-            await this.db.execute(`DROP TABLE session_handoffs`);
-            await this.db.execute(`ALTER TABLE session_handoffs_v2 RENAME TO session_handoffs`);
-            debugLog("[SqliteStorage] v3.0 migration: session_handoffs rebuilt with UNIQUE(project, user_id, role)");
+            const tx = await this.db.transaction();
+            try {
+                // Step 1: Create new table with correct constraint
+                await tx.execute(`
+          CREATE TABLE session_handoffs_v2 (
+            id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(16)))),
+            project TEXT NOT NULL,
+            user_id TEXT NOT NULL DEFAULT 'default',
+            role TEXT NOT NULL DEFAULT 'global',
+            last_summary TEXT DEFAULT NULL,
+            pending_todo TEXT DEFAULT '[]',
+            active_decisions TEXT DEFAULT '[]',
+            keywords TEXT DEFAULT '[]',
+            key_context TEXT DEFAULT NULL,
+            active_branch TEXT DEFAULT NULL,
+            version INTEGER NOT NULL DEFAULT 1,
+            metadata TEXT DEFAULT '{}',
+            created_at TEXT DEFAULT (datetime('now')),
+            updated_at TEXT DEFAULT (datetime('now')),
+            UNIQUE(project, user_id, role)
+          )
+        `);
+                // Step 2: Copy data with explicit column names (Pro-Tip 2)
+                await tx.execute(`
+          INSERT INTO session_handoffs_v2
+            (id, project, user_id, role, last_summary, pending_todo,
+             active_decisions, keywords, key_context, active_branch,
+             version, metadata, created_at, updated_at)
+          SELECT
+            id, project, user_id, 'global', last_summary, pending_todo,
+            active_decisions, keywords, key_context, active_branch,
+            version, metadata, created_at, updated_at
+          FROM session_handoffs
+        `);
+                // Step 3: Drop old and rename
+                await tx.execute(`DROP TABLE session_handoffs`);
+                await tx.execute(`ALTER TABLE session_handoffs_v2 RENAME TO session_handoffs`);
+                await tx.commit();
+                debugLog("[SqliteStorage] v3.0 migration: session_handoffs rebuilt with UNIQUE(project, user_id, role)");
+            }
+            catch (txError) {
+                await tx.rollback();
+                console.error("[SqliteStorage] v3.0 migration: session_handoffs rebuild failed, rolled back", txError);
+                throw txError;
+            }
         }
         // agent_registry: new table for Hivemind coordination
         await this.db.execute(`
@@ -393,6 +402,49 @@ export class SqliteStorage {
             if (!e.message?.includes("duplicate column name"))
                 throw e;
         }
+        // ── v5.3: Hivemind Watchdog columns on agent_registry ────────
+        // These enable the server-side health monitor to detect frozen agents,
+        // task overruns, and infinite loops. Safe no-op if columns already exist.
+        try {
+            await this.db.execute(`ALTER TABLE agent_registry ADD COLUMN task_start_time TEXT DEFAULT NULL`);
+            debugLog("[SqliteStorage] v5.3 migration: added task_start_time column");
+        }
+        catch (e) {
+            if (!e.message?.includes("duplicate column name"))
+                throw e;
+        }
+        try {
+            await this.db.execute(`ALTER TABLE agent_registry ADD COLUMN expected_duration_minutes INTEGER DEFAULT NULL`);
+            debugLog("[SqliteStorage] v5.3 migration: added expected_duration_minutes column");
+        }
+        catch (e) {
+            if (!e.message?.includes("duplicate column name"))
+                throw e;
+        }
+        try {
+            await this.db.execute(`ALTER TABLE agent_registry ADD COLUMN task_hash TEXT DEFAULT NULL`);
+            debugLog("[SqliteStorage] v5.3 migration: added task_hash column");
+        }
+        catch (e) {
+            if (!e.message?.includes("duplicate column name"))
+                throw e;
+        }
+        try {
+            await this.db.execute(`ALTER TABLE agent_registry ADD COLUMN loop_count INTEGER DEFAULT 0`);
+            debugLog("[SqliteStorage] v5.3 migration: added loop_count column");
+        }
+        catch (e) {
+            if (!e.message?.includes("duplicate column name"))
+                throw e;
+        }
+        // ─── v5.5 Migration: Superposed Distributed Memory (SDM) ───
+        await this.db.execute(`
+      CREATE TABLE IF NOT EXISTS sdm_state (
+        project TEXT PRIMARY KEY,
+        counters BLOB NOT NULL,
+        updated_at TEXT DEFAULT (datetime('now'))
+      )
+    `);
     }
     // ─── PostgREST Filter Parser ───────────────────────────────
     //
@@ -1184,7 +1236,35 @@ export class SqliteStorage {
             created_at: row.created_at,
         }));
     }
-    // ─── v2.0 Dashboard ─────────────────────────────────────────
+    // ─── v2.0 Dashboard ─────────────────────────────────────────────
+    // ─── v5.4: CRDT Base State Retrieval ───────────────────────
+    //
+    // Reads a historical handoff snapshot by version number.
+    // Used by the CRDT merge engine to reconstruct the base state
+    // that both concurrent agents originally read.
+    //
+    // This leverages the EXISTING session_handoffs_history table
+    // (created by Time Travel v2.0) — no schema changes needed.
+    async getHandoffAtVersion(project, version, userId = "default") {
+        const result = await this.db.execute({
+            sql: `SELECT snapshot FROM session_handoffs_history
+            WHERE project = ? AND user_id = ? AND version = ?
+            LIMIT 1`,
+            args: [project, userId, version],
+        });
+        if (result.rows.length === 0 || !result.rows[0].snapshot)
+            return null;
+        try {
+            const snapshot = result.rows[0].snapshot;
+            if (typeof snapshot === "string")
+                return JSON.parse(snapshot);
+            return snapshot;
+        }
+        catch {
+            console.error(`[SqliteStorage] Failed to parse history snapshot for ${project} v${version}`);
+            return null;
+        }
+    }
     async listProjects() {
         const result = await this.db.execute("SELECT DISTINCT project FROM session_handoffs ORDER BY project ASC");
         return result.rows.map(row => row.project);
@@ -1296,6 +1376,15 @@ export class SqliteStorage {
         const totalActiveEntries = Number(totalsResult.rows[0]?.active ?? 0);
         const totalHandoffs = Number(totalsResult.rows[0]?.handoffs ?? 0);
         const totalRollups = Number(totalsResult.rows[0]?.rollups ?? 0);
+        // ── v5.4: Aggregate CRDT merge counts from handoff metadata ───
+        // Each successful CRDT merge increments metadata.crdt_merge_count.
+        // We sum across all handoffs for the health report.
+        const mergesResult = await this.db.execute({
+            sql: `SELECT SUM(CAST(json_extract(metadata, '$.crdt_merge_count') AS INTEGER)) as total
+            FROM session_handoffs WHERE user_id = ?`,
+            args: [userId],
+        });
+        const totalCrdtMerges = Number(mergesResult.rows[0]?.total ?? 0);
         // ── Return the complete raw health stats ─────────────────────
         // healthCheck.ts engine will analyze this + produce HealthReport
         return {
@@ -1306,6 +1395,7 @@ export class SqliteStorage {
             totalActiveEntries, // grand total of active entries
             totalHandoffs, // grand total of handoff records
             totalRollups, // grand total of rollup entries
+            totalCrdtMerges, // v5.4: total CRDT auto-merges
         };
     }
     // ─── v3.0: Agent Registry (Hivemind) ───────────────────────
@@ -1317,8 +1407,9 @@ export class SqliteStorage {
             // Try INSERT first
             await this.db.execute({
                 sql: `INSERT INTO agent_registry
-          (id, project, user_id, role, agent_name, status, current_task)
-          VALUES (?, ?, ?, ?, ?, ?, ?)`,
+          (id, project, user_id, role, agent_name, status, current_task,
+           task_start_time, expected_duration_minutes, task_hash, loop_count)
+          VALUES (?, ?, ?, ?, ?, ?, ?, datetime('now'), NULL, NULL, 0)`,
                 args: [
                     id,
                     entry.project,
@@ -1333,13 +1424,17 @@ export class SqliteStorage {
             return { ...entry, id, status };
         }
         catch (err) {
-            // UNIQUE constraint → update existing
+            // UNIQUE constraint → update existing — reset watchdog fields on re-registration
             const msg = err instanceof Error ? err.message : String(err);
             if (msg.includes("UNIQUE") || msg.includes("constraint")) {
                 await this.db.execute({
                     sql: `UPDATE agent_registry
             SET agent_name = ?, status = ?, current_task = ?,
-                last_heartbeat = datetime('now')
+                last_heartbeat = datetime('now'),
+                task_start_time = datetime('now'),
+                expected_duration_minutes = NULL,
+                task_hash = NULL,
+                loop_count = 0
             WHERE project = ? AND user_id = ? AND role = ?`,
                     args: [
                         entry.agent_name ?? null,
@@ -1356,13 +1451,52 @@ export class SqliteStorage {
             throw err;
         }
     }
-    async heartbeatAgent(project, userId, role, currentTask) {
-        const setClauses = ["last_heartbeat = datetime('now')"];
-        const args = [];
+    async heartbeatAgent(project, userId, role, currentTask, expectedDurationMinutes) {
+        // v5.3: Loop detection — compute task hash and compare with stored value.
+        // If the hash matches, increment loop_count. If different, reset counter.
+        // This runs inline with the heartbeat UPDATE for zero additional queries.
+        const newTaskHash = currentTask
+            ? this._simpleHash(currentTask)
+            : null;
+        // Fetch current agent state for loop comparison (single SELECT)
+        const current = await this.db.execute({
+            sql: `SELECT task_hash, loop_count FROM agent_registry
+        WHERE project = ? AND user_id = ? AND role = ?`,
+            args: [project, userId, role],
+        });
+        const existingHash = current.rows[0]?.task_hash;
+        const existingLoopCount = current.rows[0]?.loop_count || 0;
+        // Determine if task changed
+        const taskChanged = newTaskHash !== null && newTaskHash !== existingHash;
+        const sameTask = newTaskHash !== null && newTaskHash === existingHash;
+        const newLoopCount = sameTask
+            ? existingLoopCount + 1
+            : (taskChanged ? 0 : existingLoopCount);
+        // Auto-detect LOOPING: if same task repeated >= 5 times, flag it
+        const newStatus = newLoopCount >= 5 ? "looping" : "active";
+        const setClauses = [
+            "last_heartbeat = datetime('now')",
+            "loop_count = ?",
+            "status = ?",
+        ];
+        const args = [newLoopCount, newStatus];
         if (currentTask !== undefined) {
             setClauses.push("current_task = ?");
             args.push(currentTask);
         }
+        if (newTaskHash !== null) {
+            setClauses.push("task_hash = ?");
+            args.push(newTaskHash);
+        }
+        // Task changed → reset task_start_time
+        if (taskChanged) {
+            setClauses.push("task_start_time = datetime('now')");
+        }
+        // Store expected duration if provided
+        if (expectedDurationMinutes !== undefined) {
+            setClauses.push("expected_duration_minutes = ?");
+            args.push(expectedDurationMinutes);
+        }
         args.push(project, userId, role);
         await this.db.execute({
             sql: `UPDATE agent_registry
@@ -1371,18 +1505,30 @@ export class SqliteStorage {
             args,
         });
     }
+    /**
+     * Simple string hash for loop detection.
+     * Uses DJB2 — fast, deterministic, no crypto overhead.
+     */
+    _simpleHash(str) {
+        let hash = 5381;
+        for (let i = 0; i < str.length; i++) {
+            hash = ((hash << 5) + hash + str.charCodeAt(i)) & 0xFFFFFFFF;
+        }
+        return hash.toString(16);
+    }
     async listTeam(project, userId, staleMinutes = 30) {
-        // Auto-prune stale agents first
+        // Auto-prune OFFLINE agents (>30min without heartbeat)
         await this.db.execute({
             sql: `DELETE FROM agent_registry
         WHERE project = ? AND user_id = ?
           AND last_heartbeat < datetime('now', '-' || ? || ' minutes')`,
             args: [project, userId, staleMinutes],
         });
-        // Fetch remaining active agents
+        // Fetch remaining agents (including watchdog columns)
         const result = await this.db.execute({
             sql: `SELECT id, project, user_id, role, agent_name, status,
-                   current_task, last_heartbeat, created_at
+                   current_task, last_heartbeat, created_at,
+                   task_start_time, expected_duration_minutes, task_hash, loop_count
             FROM agent_registry
             WHERE project = ? AND user_id = ?
             ORDER BY last_heartbeat DESC`,
@@ -1398,6 +1544,10 @@ export class SqliteStorage {
             current_task: r.current_task,
             last_heartbeat: r.last_heartbeat,
             created_at: r.created_at,
+            task_start_time: r.task_start_time,
+            expected_duration_minutes: r.expected_duration_minutes,
+            task_hash: r.task_hash,
+            loop_count: r.loop_count || 0,
         }));
     }
     async deregisterAgent(project, userId, role) {
@@ -1407,6 +1557,57 @@ export class SqliteStorage {
         });
         debugLog(`[SqliteStorage] Agent deregistered: ${project}/${role}`);
     }
+    // ─── v5.3: Hivemind Watchdog Methods ───────────────────────
+    async getAllAgents(userId) {
+        const result = await this.db.execute({
+            sql: `SELECT id, project, user_id, role, agent_name, status,
+                   current_task, last_heartbeat, created_at,
+                   task_start_time, expected_duration_minutes, task_hash, loop_count
+            FROM agent_registry
+            WHERE user_id = ?
+            ORDER BY project, role`,
+            args: [userId],
+        });
+        return result.rows.map(r => ({
+            id: r.id,
+            project: r.project,
+            user_id: r.user_id,
+            role: r.role,
+            agent_name: r.agent_name,
+            status: r.status,
+            current_task: r.current_task,
+            last_heartbeat: r.last_heartbeat,
+            created_at: r.created_at,
+            task_start_time: r.task_start_time,
+            expected_duration_minutes: r.expected_duration_minutes,
+            task_hash: r.task_hash,
+            loop_count: r.loop_count || 0,
+        }));
+    }
+    async updateAgentStatus(project, userId, role, status, additionalFields) {
+        const setClauses = ["status = ?"];
+        const args = [status];
+        // Allow watchdog to set arbitrary safe fields (e.g., loop_count reset)
+        const ALLOWED_FIELDS = new Set([
+            "loop_count", "task_start_time", "expected_duration_minutes",
+            "task_hash", "current_task",
+        ]);
+        if (additionalFields) {
+            for (const [key, val] of Object.entries(additionalFields)) {
+                if (ALLOWED_FIELDS.has(key)) {
+                    setClauses.push(`${key} = ?`);
+                    args.push(val);
+                }
+            }
+        }
+        args.push(project, userId, role);
+        await this.db.execute({
+            sql: `UPDATE agent_registry
+        SET ${setClauses.join(", ")}
+        WHERE project = ? AND user_id = ? AND role = ?`,
+            args,
+        });
+    }
     // ─── System Settings (v3.0 Dashboard) — proxy to configStorage ───
     async getSetting(key) {
         const val = await cfgGet(key, "");
@@ -1714,4 +1915,54 @@ export class SqliteStorage {
         }
         return { purged: eligible, eligible, reclaimedBytes };
     }
+    // ─── v5.5: SDM Persistence ───────────────────────────────────
+    async loadSdmState(project) {
+        const result = await this.db.execute({
+            sql: `SELECT counters FROM sdm_state WHERE project = ?`,
+            args: [project],
+        });
+        if (result.rows.length === 0) {
+            return null;
+        }
+        const blob = result.rows[0].counters;
+        // libSQL returns blobs as ArrayBuffer.
+        // We instantiate a Float32Array directly over the buffer.
+        if (blob instanceof ArrayBuffer) {
+            return new Float32Array(blob);
+        }
+        else if (blob instanceof Uint8Array) {
+            // In case it's returned as a Uint8Array view
+            return new Float32Array(blob.buffer, blob.byteOffset, blob.byteLength / 4);
+        }
+        else {
+            throw new Error(`[SqliteStorage] Unexpected blob type returned for SDM state`);
+        }
+    }
+    async saveSdmState(project, state) {
+        // The state is a Float32Array. We need its underlying buffer for SQLite.
+        // Wrap in Uint8Array to satisfy @libsql/client InValue typing which rejects SharedArrayBuffer
+        const buffer = new Uint8Array(state.buffer, state.byteOffset, state.byteLength);
+        // We do an UPSERT (INSERT ... ON CONFLICT REPLACE).
+        await this.db.execute({
+            sql: `INSERT INTO sdm_state (project, counters, updated_at) 
+            VALUES (?, ?, datetime('now'))
+            ON CONFLICT(project) DO UPDATE SET 
+              counters = excluded.counters,
+              updated_at = excluded.updated_at`,
+            args: [project, buffer],
+        });
+        debugLog(`[SqliteStorage] Persisted SDM state to disk for project: ${project}`);
+    }
+    async getAllProjectEmbeddings(project) {
+        const res = await this.db.execute({
+            sql: `SELECT id, summary, embedding_compressed FROM session_ledger
+            WHERE project = ? AND deleted_at IS NULL AND embedding_compressed IS NOT NULL`,
+            args: [project]
+        });
+        return res.rows.map(r => ({
+            id: r.id,
+            summary: r.summary,
+            embedding_compressed: r.embedding_compressed
+        }));
+    }
 }

package/dist/storage/supabase.js

@@ -186,6 +186,29 @@ export class SupabaseStorage {
         });
         return (Array.isArray(data) ? data : []);
     }
+    // ─── v5.4: CRDT Base State Retrieval ───────────────────────
+    //
+    // Reads a historical handoff snapshot by version number via
+    // Supabase REST API. Used by the CRDT merge engine.
+    async getHandoffAtVersion(project, version, userId = "default") {
+        try {
+            const data = await supabaseGet("session_handoffs_history", {
+                select: "snapshot",
+                project: `eq.${project}`,
+                user_id: `eq.${userId}`,
+                version: `eq.${version}`,
+                limit: "1",
+            });
+            const rows = Array.isArray(data) ? data : [];
+            if (rows.length === 0)
+                return null;
+            return rows[0].snapshot || null;
+        }
+        catch (err) {
+            console.error(`[SupabaseStorage] Failed to get handoff at version ${version}: ${err}`);
+            return null;
+        }
+    }
     // ─── v2.0 Dashboard ─────────────────────────────────────────
     async listProjects() {
         const data = await supabaseGet("session_handoffs", {
@@ -248,6 +271,13 @@ export class SupabaseStorage {
         const totalActiveEntries = activeLedgerSummaries.length;
         const totalHandoffs = handoffProjects.size;
         const totalRollups = rollups.length;
+        // v5.4: Aggregate CRDT merge counts from handoff metadata
+        const handoffFullData = await supabaseGet("session_handoffs", {
+            select: "metadata",
+            user_id: `eq.${userId}`,
+        });
+        const handoffRows = Array.isArray(handoffFullData) ? handoffFullData : [];
+        const totalCrdtMerges = handoffRows.reduce((sum, h) => sum + (h.metadata?.crdt_merge_count || 0), 0);
         return {
             missingEmbeddings,
             activeLedgerSummaries,
@@ -256,6 +286,7 @@ export class SupabaseStorage {
             totalActiveEntries,
             totalHandoffs,
             totalRollups,
+            totalCrdtMerges,
         };
     }
     // ─── v3.0: Agent Registry (Hivemind) ───────────────────────
@@ -268,18 +299,63 @@ export class SupabaseStorage {
             agent_name: entry.agent_name ?? null,
             status: entry.status || "active",
             current_task: entry.current_task ?? null,
+            // v5.3: Initialize watchdog fields
+            task_start_time: new Date().toISOString(),
+            expected_duration_minutes: null,
+            task_hash: null,
+            loop_count: 0,
         };
         const result = await supabasePost("agent_registry", record);
         const data = Array.isArray(result) ? result[0] : result;
         return { ...entry, id: data?.id, status: entry.status || "active" };
     }
-    async heartbeatAgent(project, userId, role, currentTask) {
+    /**
+     * Simple string hash for loop detection (DJB2).
+     * Mirrors SqliteStorage._simpleHash().
+     */
+    _simpleHash(str) {
+        let hash = 5381;
+        for (let i = 0; i < str.length; i++) {
+            hash = ((hash << 5) + hash + str.charCodeAt(i)) & 0xFFFFFFFF;
+        }
+        return hash.toString(16);
+    }
+    async heartbeatAgent(project, userId, role, currentTask, expectedDurationMinutes) {
+        // v5.3: Loop detection — compute task hash and compare with stored value
+        const newTaskHash = currentTask ? this._simpleHash(currentTask) : null;
+        // Fetch current agent for loop comparison
+        const current = await supabaseGet("agent_registry", {
+            project: `eq.${project}`,
+            user_id: `eq.${userId}`,
+            role: `eq.${role}`,
+            select: "task_hash,loop_count",
+        });
+        const agentRow = Array.isArray(current) ? current[0] : current;
+        const existingHash = agentRow?.task_hash;
+        const existingLoopCount = agentRow?.loop_count || 0;
+        const taskChanged = newTaskHash !== null && newTaskHash !== existingHash;
+        const sameTask = newTaskHash !== null && newTaskHash === existingHash;
+        const newLoopCount = sameTask
+            ? existingLoopCount + 1
+            : (taskChanged ? 0 : existingLoopCount);
+        const newStatus = newLoopCount >= 5 ? "looping" : "active";
         const patchData = {
             last_heartbeat: new Date().toISOString(),
+            loop_count: newLoopCount,
+            status: newStatus,
         };
         if (currentTask !== undefined) {
             patchData.current_task = currentTask;
         }
+        if (newTaskHash !== null) {
+            patchData.task_hash = newTaskHash;
+        }
+        if (taskChanged) {
+            patchData.task_start_time = new Date().toISOString();
+        }
+        if (expectedDurationMinutes !== undefined) {
+            patchData.expected_duration_minutes = expectedDurationMinutes;
+        }
         await supabasePatch("agent_registry", patchData, {
             project: `eq.${project}`,
             user_id: `eq.${userId}`,
@@ -301,6 +377,33 @@ export class SupabaseStorage {
             role: `eq.${role}`,
         });
     }
+    // ─── v5.3: Hivemind Watchdog Methods ───────────────────────
+    async getAllAgents(userId) {
+        const data = await supabaseGet("agent_registry", {
+            user_id: `eq.${userId}`,
+            order: "project,role",
+        });
+        return (Array.isArray(data) ? data : []);
+    }
+    async updateAgentStatus(project, userId, role, status, additionalFields) {
+        const patchData = { status };
+        const ALLOWED_FIELDS = new Set([
+            "loop_count", "task_start_time", "expected_duration_minutes",
+            "task_hash", "current_task",
+        ]);
+        if (additionalFields) {
+            for (const [key, val] of Object.entries(additionalFields)) {
+                if (ALLOWED_FIELDS.has(key)) {
+                    patchData[key] = val;
+                }
+            }
+        }
+        await supabasePatch("agent_registry", patchData, {
+            project: `eq.${project}`,
+            user_id: `eq.${userId}`,
+            role: `eq.${role}`,
+        });
+    }
     // ─── System Settings (v3.0 Dashboard) — proxy to configStorage ───
     async getSetting(key) {
         const val = await cfgGet(key, "");
@@ -500,4 +603,14 @@ export class SupabaseStorage {
             throw e;
         }
     }
+    // ─── SDM Operations ──────────────────────────────────────────
+    async loadSdmState(project) {
+        throw new Error("loading SDM state is not implemented for Supabase backend yet.");
+    }
+    async saveSdmState(project, state) {
+        throw new Error("saving SDM state is not implemented for Supabase backend yet.");
+    }
+    async getAllProjectEmbeddings(project) {
+        throw new Error("getting compressed embeddings for Hamming scan is not implemented for Supabase backend yet.");
+    }
 }

package/dist/tools/agentRegistryDefinitions.js

@@ -60,7 +60,8 @@ export const AGENT_HEARTBEAT_TOOL = {
     name: "agent_heartbeat",
     description: "Update your heartbeat and optionally your current task. " +
         "Call this periodically to stay visible to the team. " +
-        "Agents that haven't sent a heartbeat in 30 minutes are auto-pruned.",
+        "The server-side Watchdog monitors health every 60 seconds — agents that miss " +
+        "heartbeats transition through STALE → FROZEN → OFFLINE (auto-pruned).",
     inputSchema: {
         type: "object",
         properties: {
@@ -76,15 +77,21 @@ export const AGENT_HEARTBEAT_TOOL = {
                 type: "string",
                 description: "Optional updated description of your current task.",
             },
+            expected_duration_minutes: {
+                type: "number",
+                description: "Optional estimated duration for the current task in minutes. " +
+                    "If the task exceeds this duration, the Watchdog flags the agent as OVERDUE " +
+                    "and alerts teammates. Typical values: 5 for quick fixes, 15 for features, 30 for refactors.",
+            },
         },
         required: ["project", "role"],
     },
 };
 export const AGENT_LIST_TEAM_TOOL = {
     name: "agent_list_team",
-    description: "List all active agents on a project. Shows role, status, current task, " +
-        "and last heartbeat time. Automatically prunes agents that haven't " +
-        "reported in 30+ minutes.",
+    description: "List all agents on a project with health status. Shows role, health state " +
+        "(🟢 ACTIVE / 🟡 STALE / 🔴 FROZEN / ⏰ OVERDUE / 🔄 LOOPING), current task, " +
+        "and last heartbeat time. The server-side Watchdog actively monitors agent health every 60 seconds.",
     inputSchema: {
         type: "object",
         properties: {