@adhdev/daemon-core 0.9.82-rc.209 → 0.9.82-rc.210

package/src/mesh/mesh-runtime-store.ts

@@ -186,6 +186,73 @@ export class MeshRuntimeStore {
 
             CREATE INDEX IF NOT EXISTS idx_mesh_completion_conflicts_mesh
                 ON mesh_completion_conflicts(mesh_id, created_at);
+
+            CREATE TABLE IF NOT EXISTS mesh_tool_call_log (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                mesh_id TEXT NOT NULL,
+                tool TEXT NOT NULL,
+                session_id TEXT,
+                called_at INTEGER NOT NULL
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_mesh_tool_call_log_mesh_tool_time
+                ON mesh_tool_call_log(mesh_id, tool, called_at);
+
+            -- G2: Event ledger — runtime source of truth for task/session lifecycle events.
+            -- JSONL files are retained as export/import/debug/legacy artifacts only.
+            CREATE TABLE IF NOT EXISTS mesh_event_ledger (
+                id TEXT PRIMARY KEY,
+                mesh_id TEXT NOT NULL,
+                timestamp TEXT NOT NULL,
+                kind TEXT NOT NULL,
+                node_id TEXT,
+                session_id TEXT,
+                provider_type TEXT,
+                payload TEXT NOT NULL DEFAULT '{}'
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_mesh_event_ledger_mesh_time
+                ON mesh_event_ledger(mesh_id, timestamp);
+            CREATE INDEX IF NOT EXISTS idx_mesh_event_ledger_mesh_kind
+                ON mesh_event_ledger(mesh_id, kind, timestamp);
+            CREATE INDEX IF NOT EXISTS idx_mesh_event_ledger_session
+                ON mesh_event_ledger(mesh_id, session_id, timestamp);
+
+            -- G3: Pending coordinator event inbox — replaces <meshId>.pending-events.jsonl.
+            -- Coordinator drains this table on get_pending_mesh_events, then deletes drained rows.
+            CREATE TABLE IF NOT EXISTS mesh_pending_events (
+                id TEXT PRIMARY KEY,
+                mesh_id TEXT NOT NULL,
+                coordinator_daemon_id TEXT,
+                event TEXT NOT NULL,
+                payload TEXT NOT NULL DEFAULT '{}',
+                fingerprint TEXT,
+                queued_at INTEGER NOT NULL,
+                drained INTEGER NOT NULL DEFAULT 0,
+                drained_at INTEGER
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_mesh_pending_events_mesh_drained
+                ON mesh_pending_events(mesh_id, drained, queued_at);
+            CREATE UNIQUE INDEX IF NOT EXISTS idx_mesh_pending_events_fingerprint
+                ON mesh_pending_events(mesh_id, fingerprint)
+                WHERE fingerprint IS NOT NULL;
+
+            -- M3: persistent mission records. Plans live in the system, not in the
+            -- coordinator LLM's context. Progress is derived from task statuses at
+            -- query time (mission_id on queue tasks) — never stored here.
+            CREATE TABLE IF NOT EXISTS mesh_missions (
+                id TEXT PRIMARY KEY,
+                mesh_id TEXT NOT NULL,
+                title TEXT NOT NULL,
+                goal TEXT NOT NULL DEFAULT '',
+                status TEXT NOT NULL DEFAULT 'active',
+                created_at TEXT NOT NULL,
+                updated_at TEXT NOT NULL
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_mesh_missions_mesh_status
+                ON mesh_missions(mesh_id, status, updated_at);
         `);
     }
 
@@ -385,9 +452,28 @@ export class MeshRuntimeStore {
                 `).all(meshId) as Array<{ payload: string }>
                 ),
             ];
-            const entry = rows
-                .map(row => JSON.parse(row.payload) as MeshWorkQueueEntry)
-                .find(candidate => nodeSatisfiesRequiredTags(candidate.requiredTags, capabilityTags));
+            const candidates = rows.map(row => JSON.parse(row.payload) as MeshWorkQueueEntry);
+
+            // M1: a task with unmet dependencies (or a system blockedReason) is not claimable.
+            // Resolve dependency statuses in one query over the union of referenced ids.
+            const depIds = [...new Set(candidates.flatMap(c => Array.isArray(c.dependsOn) ? c.dependsOn : []))];
+            const depStatus = new Map<string, string>();
+            if (depIds.length > 0) {
+                const placeholders = depIds.map(() => '?').join(', ');
+                const depRows = this.db.prepare(
+                    `SELECT id, status FROM mesh_queue WHERE mesh_id = ? AND id IN (${placeholders})`
+                ).all(meshId, ...depIds) as Array<{ id: string; status: string }>;
+                for (const r of depRows) depStatus.set(r.id, r.status);
+            }
+            const dependenciesSatisfied = (candidate: MeshWorkQueueEntry): boolean => {
+                if (candidate.blockedReason) return false;
+                const deps = Array.isArray(candidate.dependsOn) ? candidate.dependsOn : [];
+                return deps.every(depId => depStatus.get(depId) === 'completed');
+            };
+
+            const entry = candidates.find(candidate =>
+                nodeSatisfiesRequiredTags(candidate.requiredTags, capabilityTags)
+                && dependenciesSatisfied(candidate));
             if (!entry) return null;
 
             const now = new Date().toISOString();
@@ -766,4 +852,454 @@ export class MeshRuntimeStore {
             createdAt: r.created_at as string,
         }));
     }
+
+    /**
+     * Record a mesh tool call and check whether this mesh+tool combination is
+     * being called too rapidly (sliding window rate guard).
+     *
+     * Returns a rate-limit advisory string when the call rate is too high, null otherwise.
+     * windowMs: sliding window size in ms (default 10s)
+     * maxCalls: max allowed calls within the window (default 5)
+     */
+    recordMeshToolCall(opts: {
+        meshId: string;
+        tool: string;
+        sessionId?: string | null;
+        windowMs?: number;
+        maxCalls?: number;
+    }): { rateLimitExceeded: boolean; callsInWindow: number; advisory: string | null } {
+        const { meshId, tool, sessionId = null } = opts;
+        const windowMs = opts.windowMs ?? 10_000;
+        const maxCalls = opts.maxCalls ?? 5;
+        const now = Date.now();
+        const windowStart = now - windowMs;
+
+        this.db.prepare(
+            'INSERT INTO mesh_tool_call_log (mesh_id, tool, session_id, called_at) VALUES (?, ?, ?, ?)'
+        ).run(meshId, tool, sessionId, now);
+
+        const row = this.db.prepare(
+            'SELECT COUNT(*) as cnt FROM mesh_tool_call_log WHERE mesh_id = ? AND tool = ? AND called_at >= ?'
+        ).get(meshId, tool, windowStart) as { cnt: number };
+        const callsInWindow = row?.cnt ?? 0;
+
+        // Sweep old entries periodically to keep the table lean (every 200 calls across all tools).
+        if (++this.walWriteCounter % 200 === 0) {
+            this.db.prepare(
+                'DELETE FROM mesh_tool_call_log WHERE called_at < ?'
+            ).run(now - Math.max(windowMs * 10, 60_000));
+        }
+
+        if (callsInWindow > maxCalls) {
+            const advisory = `Rate limit: ${tool} called ${callsInWindow} times in the last ${windowMs / 1000}s for mesh ${meshId}. `
+                + `Wait for pendingCoordinatorEvents or an explicit user status request before calling again.`;
+            return { rateLimitExceeded: true, callsInWindow, advisory };
+        }
+        return { rateLimitExceeded: false, callsInWindow, advisory: null };
+    }
+
+    /**
+     * Prune tool call log entries older than the given age in ms.
+     * Exposed for testing.
+     */
+    pruneToolCallLog(olderThanMs: number): void {
+        this.db.prepare('DELETE FROM mesh_tool_call_log WHERE called_at < ?').run(Date.now() - olderThanMs);
+    }
+
+    // ── G2: Event Ledger ────────────────────────────────────────────────────
+
+    appendLedgerEntry(entry: {
+        id: string;
+        meshId: string;
+        timestamp: string;
+        kind: string;
+        nodeId?: string | null;
+        sessionId?: string | null;
+        providerType?: string | null;
+        payload?: unknown;
+    }): void {
+        this.db.prepare(
+            `INSERT OR IGNORE INTO mesh_event_ledger
+             (id, mesh_id, timestamp, kind, node_id, session_id, provider_type, payload)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+        ).run(
+            entry.id,
+            entry.meshId,
+            entry.timestamp,
+            entry.kind,
+            entry.nodeId ?? null,
+            entry.sessionId ?? null,
+            entry.providerType ?? null,
+            JSON.stringify(entry.payload ?? {}),
+        );
+        this.maybeCheckpointWal();
+    }
+
+    readLedgerEntries(meshId: string, opts?: {
+        tail?: number;
+        since?: string;
+        kind?: string;
+        limit?: number;
+    }): Array<{ id: string; meshId: string; timestamp: string; kind: string; nodeId: string | null; sessionId: string | null; providerType: string | null; payload: unknown }> {
+        const limit = opts?.tail ?? opts?.limit ?? 200;
+        let query: string;
+        const params: unknown[] = [meshId];
+        if (opts?.kind && opts?.since) {
+            query = `SELECT * FROM mesh_event_ledger WHERE mesh_id = ? AND kind = ? AND timestamp >= ? ORDER BY timestamp DESC LIMIT ?`;
+            params.push(opts.kind, opts.since, limit);
+        } else if (opts?.kind) {
+            query = `SELECT * FROM mesh_event_ledger WHERE mesh_id = ? AND kind = ? ORDER BY timestamp DESC LIMIT ?`;
+            params.push(opts.kind, limit);
+        } else if (opts?.since) {
+            query = `SELECT * FROM mesh_event_ledger WHERE mesh_id = ? AND timestamp >= ? ORDER BY timestamp DESC LIMIT ?`;
+            params.push(opts.since, limit);
+        } else {
+            query = `SELECT * FROM mesh_event_ledger WHERE mesh_id = ? ORDER BY timestamp DESC LIMIT ?`;
+            params.push(limit);
+        }
+        const rows = this.db.prepare(query).all(...params) as Array<Record<string, unknown>>;
+        return rows.map(r => ({
+            id: r.id as string,
+            meshId: r.mesh_id as string,
+            timestamp: r.timestamp as string,
+            kind: r.kind as string,
+            nodeId: r.node_id as string | null,
+            sessionId: r.session_id as string | null,
+            providerType: r.provider_type as string | null,
+            payload: (() => { try { return JSON.parse(r.payload as string); } catch { return {}; } })(),
+        }));
+    }
+
+    /**
+     * G2 read cutover: read ledger entries in append order (oldest first),
+     * matching legacy JSONL file-order semantics. Ties on the same timestamp
+     * are broken by rowid (insertion order), preserving the positional
+     * guarantee that mesh-events relies on for same-millisecond entries.
+     */
+    readLedgerEntriesOrdered(meshId: string, opts?: {
+        since?: string;
+        kinds?: string[];
+        tail?: number;
+    }): Array<{ id: string; meshId: string; timestamp: string; kind: string; nodeId: string | null; sessionId: string | null; providerType: string | null; payload: unknown }> {
+        const params: unknown[] = [meshId];
+        let whereClause = 'mesh_id = ?';
+        if (opts?.since) {
+            whereClause += ' AND timestamp >= ?';
+            params.push(opts.since);
+        }
+        const kinds = Array.isArray(opts?.kinds) ? opts.kinds.filter(k => typeof k === 'string' && k.trim()) : [];
+        if (kinds.length > 0) {
+            whereClause += ` AND kind IN (${kinds.map(() => '?').join(', ')})`;
+            params.push(...kinds);
+        }
+        let query: string;
+        if (opts?.tail && opts.tail > 0) {
+            // Tail: newest N in append order — inner DESC limit, outer re-sort ASC.
+            query = `SELECT * FROM (
+                SELECT rowid AS rid, * FROM mesh_event_ledger WHERE ${whereClause}
+                ORDER BY timestamp DESC, rowid DESC LIMIT ?
+            ) ORDER BY timestamp ASC, rid ASC`;
+            params.push(Math.floor(opts.tail));
+        } else {
+            query = `SELECT rowid AS rid, * FROM mesh_event_ledger WHERE ${whereClause} ORDER BY timestamp ASC, rowid ASC`;
+        }
+        const rows = this.db.prepare(query).all(...params) as Array<Record<string, unknown>>;
+        return rows.map(r => ({
+            id: r.id as string,
+            meshId: r.mesh_id as string,
+            timestamp: r.timestamp as string,
+            kind: r.kind as string,
+            nodeId: r.node_id as string | null,
+            sessionId: r.session_id as string | null,
+            providerType: r.provider_type as string | null,
+            payload: (() => { try { return JSON.parse(r.payload as string); } catch { return {}; } })(),
+        }));
+    }
+
+    /** Remove all ledger entries for a mesh (mesh deletion / test cleanup). */
+    clearLedgerForMesh(meshId: string): number {
+        return this.db.prepare('DELETE FROM mesh_event_ledger WHERE mesh_id = ?').run(meshId).changes;
+    }
+
+    /** G2: remove entries moved to the JSONL archive so the SQLite runtime set mirrors the active ledger. */
+    deleteLedgerEntries(meshId: string, ids: string[]): number {
+        if (!ids.length) return 0;
+        let deleted = 0;
+        const stmt = this.db.prepare('DELETE FROM mesh_event_ledger WHERE mesh_id = ? AND id = ?');
+        this.db.transaction(() => {
+            for (const id of ids) {
+                deleted += stmt.run(meshId, id).changes;
+            }
+        })();
+        return deleted;
+    }
+
+    hasLedgerEntry(meshId: string, id: string): boolean {
+        const row = this.db.prepare(
+            'SELECT 1 FROM mesh_event_ledger WHERE mesh_id = ? AND id = ? LIMIT 1'
+        ).get(meshId, id);
+        return row !== undefined;
+    }
+
+    ledgerEntryCount(meshId: string): number {
+        const row = this.db.prepare(
+            'SELECT COUNT(*) as cnt FROM mesh_event_ledger WHERE mesh_id = ?'
+        ).get(meshId) as { cnt: number } | undefined;
+        return row?.cnt ?? 0;
+    }
+
+    importLedgerEntries(entries: Array<{
+        id: string; meshId: string; timestamp: string; kind: string;
+        nodeId?: string | null; sessionId?: string | null; providerType?: string | null; payload?: unknown;
+    }>): number {
+        let imported = 0;
+        const stmt = this.db.prepare(
+            `INSERT OR IGNORE INTO mesh_event_ledger
+             (id, mesh_id, timestamp, kind, node_id, session_id, provider_type, payload)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+        );
+        this.db.transaction(() => {
+            for (const e of entries) {
+                const result = stmt.run(
+                    e.id, e.meshId, e.timestamp, e.kind,
+                    e.nodeId ?? null, e.sessionId ?? null, e.providerType ?? null,
+                    JSON.stringify(e.payload ?? {}),
+                );
+                if (result.changes > 0) imported++;
+            }
+        })();
+        return imported;
+    }
+
+    /**
+     * G4: Read a bounded, cursor-addressable ledger slice directly from the SQLite
+     * mesh_event_ledger table. This is the P2P reconcile read path; JSONL files are
+     * retained as export/import/debug/legacy artifacts only.
+     *
+     * The return shape is structurally compatible with MeshLedgerSlice so callers
+     * in mesh-tools.ts can pass it directly to buildMeshLedgerReplicaEvidence.
+     */
+    readLedgerSlice(meshId: string, opts?: {
+        afterId?: string;
+        since?: string;
+        kind?: string;
+        limit?: number;
+    }): {
+        protocol: 'adhdev.mesh.ledger.slice.v1';
+        meshId: string;
+        entries: Array<{ id: string; meshId: string; timestamp: string; kind: string; nodeId: string | null; sessionId: string | null; providerType: string | null; payload: unknown }>;
+        cursor: { afterId: string | null; nextAfterId: string | null; limit: number; hasMore: boolean };
+        sourceOfTruth: { kind: 'local_sqlite'; table: 'mesh_event_ledger'; bounded: true; maxLimit: number };
+    } {
+        // Protocol maximum of 500, default 100 — mirrors mesh-ledger.ts constants.
+        const MAX_LIMIT = 500;
+        const DEFAULT_LIMIT = 100;
+        const limit = (typeof opts?.limit === 'number' && Number.isFinite(opts.limit))
+            ? Math.max(1, Math.min(MAX_LIMIT, Math.floor(opts.limit)))
+            : DEFAULT_LIMIT;
+
+        const afterId = typeof opts?.afterId === 'string' && opts.afterId.trim() ? opts.afterId.trim() : null;
+
+        // Build query: fetch limit+1 rows so we can detect hasMore without a COUNT(*).
+        const params: unknown[] = [meshId];
+        let whereClause = 'mesh_id = ?';
+
+        if (opts?.kind) {
+            whereClause += ' AND kind = ?';
+            params.push(opts.kind);
+        }
+        if (opts?.since) {
+            whereClause += ' AND timestamp >= ?';
+            params.push(opts.since);
+        }
+        if (afterId) {
+            // afterId: return entries with timestamp strictly after the referenced entry's timestamp,
+            // or with the same timestamp but id > afterId (stable pagination).
+            whereClause += ` AND (timestamp > (SELECT timestamp FROM mesh_event_ledger WHERE id = ? AND mesh_id = ?) OR (timestamp = (SELECT timestamp FROM mesh_event_ledger WHERE id = ? AND mesh_id = ?) AND id > ?))`;
+            params.push(afterId, meshId, afterId, meshId, afterId);
+        }
+
+        // Fetch limit+1 to detect hasMore
+        const query = `SELECT * FROM mesh_event_ledger WHERE ${whereClause} ORDER BY timestamp ASC, id ASC LIMIT ?`;
+        params.push(limit + 1);
+
+        const rows = this.db.prepare(query).all(...params) as Array<Record<string, unknown>>;
+        const hasMore = rows.length > limit;
+        const bounded = hasMore ? rows.slice(0, limit) : rows;
+
+        const entries = bounded.map(r => ({
+            id: r.id as string,
+            meshId: r.mesh_id as string,
+            timestamp: r.timestamp as string,
+            kind: r.kind as string,
+            nodeId: r.node_id as string | null,
+            sessionId: r.session_id as string | null,
+            providerType: r.provider_type as string | null,
+            payload: (() => { try { return JSON.parse(r.payload as string); } catch { return {}; } })(),
+        }));
+
+        return {
+            protocol: 'adhdev.mesh.ledger.slice.v1',
+            meshId,
+            entries,
+            cursor: {
+                afterId,
+                nextAfterId: entries.length ? entries[entries.length - 1].id : afterId,
+                limit,
+                hasMore,
+            },
+            sourceOfTruth: {
+                kind: 'local_sqlite',
+                table: 'mesh_event_ledger',
+                bounded: true,
+                maxLimit: MAX_LIMIT,
+            },
+        };
+    }
+
+    // ── G3: Pending Coordinator Events ──────────────────────────────────────
+
+    insertPendingEvent(event: {
+        id: string;
+        meshId: string;
+        coordinatorDaemonId?: string | null;
+        event: string;
+        payload?: unknown;
+        fingerprint?: string | null;
+        queuedAt: number;
+    }): boolean {
+        const result = this.db.prepare(
+            `INSERT OR IGNORE INTO mesh_pending_events
+             (id, mesh_id, coordinator_daemon_id, event, payload, fingerprint, queued_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?)`
+        ).run(
+            event.id,
+            event.meshId,
+            event.coordinatorDaemonId ?? null,
+            event.event,
+            JSON.stringify(event.payload ?? {}),
+            event.fingerprint ?? null,
+            event.queuedAt,
+        );
+        this.maybeCheckpointWal();
+        return result.changes > 0;
+    }
+
+    drainPendingEvents(meshId: string, coordinatorDaemonId?: string | null): Array<{ id: string; event: string; payload: unknown }> {
+        return this.transaction(() => {
+            const whereClause = coordinatorDaemonId
+                ? `WHERE mesh_id = ? AND drained = 0 AND (coordinator_daemon_id IS NULL OR coordinator_daemon_id = ?)`
+                : `WHERE mesh_id = ? AND drained = 0`;
+            const params: unknown[] = coordinatorDaemonId
+                ? [meshId, coordinatorDaemonId]
+                : [meshId];
+            const rows = this.db.prepare(
+                `SELECT id, event, payload FROM mesh_pending_events ${whereClause} ORDER BY queued_at ASC LIMIT 100`
+            ).all(...params) as Array<{ id: string; event: string; payload: string }>;
+            if (rows.length === 0) return [];
+            const ids = rows.map(r => r.id);
+            const now = Date.now();
+            this.db.prepare(
+                `UPDATE mesh_pending_events SET drained = 1, drained_at = ? WHERE id IN (${ids.map(() => '?').join(',')})`
+            ).run(now, ...ids);
+            return rows.map(r => ({
+                id: r.id,
+                event: r.event,
+                payload: (() => { try { return JSON.parse(r.payload); } catch { return {}; } })(),
+            }));
+        });
+    }
+
+    /** Non-destructive peek — returns undrained events without marking them drained. */
+    peekPendingEvents(meshId: string, coordinatorDaemonId?: string | null): Array<{ id: string; event: string; payload: unknown }> {
+        const whereClause = coordinatorDaemonId
+            ? `WHERE mesh_id = ? AND drained = 0 AND (coordinator_daemon_id IS NULL OR coordinator_daemon_id = ?)`
+            : `WHERE mesh_id = ? AND drained = 0`;
+        const params: unknown[] = coordinatorDaemonId ? [meshId, coordinatorDaemonId] : [meshId];
+        const rows = this.db.prepare(
+            `SELECT id, event, payload FROM mesh_pending_events ${whereClause} ORDER BY queued_at ASC LIMIT 100`
+        ).all(...params) as Array<{ id: string; event: string; payload: string }>;
+        return rows.map(r => ({
+            id: r.id,
+            event: r.event,
+            payload: (() => { try { return JSON.parse(r.payload); } catch { return {}; } })(),
+        }));
+    }
+
+    hasPendingEventFingerprint(meshId: string, fingerprint: string): boolean {
+        const row = this.db.prepare(
+            'SELECT 1 FROM mesh_pending_events WHERE mesh_id = ? AND fingerprint = ? AND drained = 0 LIMIT 1'
+        ).get(meshId, fingerprint);
+        return row !== undefined;
+    }
+
+    // ── M3: Mission Records ─────────────────────────────────────────────────
+
+    upsertMission(mission: {
+        id: string;
+        meshId: string;
+        title: string;
+        goal?: string;
+        status?: string;
+    }): void {
+        const now = new Date().toISOString();
+        this.db.prepare(
+            `INSERT INTO mesh_missions (id, mesh_id, title, goal, status, created_at, updated_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?)
+             ON CONFLICT(id) DO UPDATE SET
+                 title = excluded.title,
+                 goal = excluded.goal,
+                 status = excluded.status,
+                 updated_at = excluded.updated_at`
+        ).run(
+            mission.id,
+            mission.meshId,
+            mission.title,
+            mission.goal ?? '',
+            mission.status ?? 'active',
+            now,
+            now,
+        );
+        this.maybeCheckpointWal();
+    }
+
+    getMission(meshId: string, missionId: string): { id: string; meshId: string; title: string; goal: string; status: string; createdAt: string; updatedAt: string } | null {
+        const row = this.db.prepare(
+            'SELECT * FROM mesh_missions WHERE mesh_id = ? AND id = ?'
+        ).get(meshId, missionId) as Record<string, string> | undefined;
+        if (!row) return null;
+        return { id: row.id, meshId: row.mesh_id, title: row.title, goal: row.goal, status: row.status, createdAt: row.created_at, updatedAt: row.updated_at };
+    }
+
+    getMissions(meshId: string, statuses?: string[]): Array<{ id: string; meshId: string; title: string; goal: string; status: string; createdAt: string; updatedAt: string }> {
+        let rows: Array<Record<string, string>>;
+        if (statuses?.length) {
+            const placeholders = statuses.map(() => '?').join(', ');
+            rows = this.db.prepare(
+                `SELECT * FROM mesh_missions WHERE mesh_id = ? AND status IN (${placeholders}) ORDER BY updated_at DESC`
+            ).all(meshId, ...statuses) as Array<Record<string, string>>;
+        } else {
+            rows = this.db.prepare(
+                'SELECT * FROM mesh_missions WHERE mesh_id = ? ORDER BY updated_at DESC'
+            ).all(meshId) as Array<Record<string, string>>;
+        }
+        return rows.map(row => ({ id: row.id, meshId: row.mesh_id, title: row.title, goal: row.goal, status: row.status, createdAt: row.created_at, updatedAt: row.updated_at }));
+    }
+
+    /** Remove all missions for a mesh — mesh deletion / test cleanup. */
+    clearMissionsForMesh(meshId: string): number {
+        return this.db.prepare('DELETE FROM mesh_missions WHERE mesh_id = ?').run(meshId).changes;
+    }
+
+    /** Remove all pending-event rows (drained included) for a mesh — mesh deletion / test cleanup. */
+    clearPendingEventsForMesh(meshId: string): number {
+        return this.db.prepare('DELETE FROM mesh_pending_events WHERE mesh_id = ?').run(meshId).changes;
+    }
+
+    pendingEventCount(meshId: string): number {
+        const row = this.db.prepare(
+            'SELECT COUNT(*) as cnt FROM mesh_pending_events WHERE mesh_id = ? AND drained = 0'
+        ).get(meshId) as { cnt: number } | undefined;
+        return row?.cnt ?? 0;
+    }
 }