openclaw-node-harness 2.0.0

package/mission-control/src/app/api/memory/items/route.ts

@@ -0,0 +1,86 @@
+import { NextRequest, NextResponse } from "next/server";
+import {
+  storeExtractedFacts,
+  getItemsWithSource,
+  searchItems,
+  getExtractionStats,
+  type GatedFact,
+} from "@/lib/memory/extract";
+
+/**
+ * GET /api/memory/items?category=work&limit=50&offset=0&q=search
+ * List active memory items, optionally filtered by category or search query.
+ * Add ?stats=true for extraction statistics.
+ */
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = request.nextUrl;
+
+    // Stats mode
+    if (searchParams.get("stats") === "true") {
+      const stats = getExtractionStats();
+      return NextResponse.json(stats);
+    }
+
+    const category = searchParams.get("category") || undefined;
+    const query = searchParams.get("q");
+    const limit = Math.min(parseInt(searchParams.get("limit") || "50", 10), 200);
+    const offset = parseInt(searchParams.get("offset") || "0", 10);
+
+    // Search mode
+    if (query && query.trim().length >= 2) {
+      const results = searchItems(query, category, limit);
+      return NextResponse.json({ items: results, total: results.length });
+    }
+
+    // List mode
+    const items = getItemsWithSource(limit, offset);
+    return NextResponse.json({ items, limit, offset });
+  } catch (err) {
+    console.error("GET /api/memory/items error:", err);
+    return NextResponse.json(
+      { error: "Failed to fetch memory items" },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * POST /api/memory/items
+ * Store extracted + gated facts.
+ * Body: { facts: GatedFact[], sourceDocId?: number, extractionSource?: string }
+ *
+ * Called by Daedalus after inline extraction + gating,
+ * or by a sub-agent doing batch extraction.
+ */
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const { facts, sourceDocId, extractionSource } = body as {
+      facts: GatedFact[];
+      sourceDocId?: number;
+      extractionSource?: string;
+    };
+
+    if (!facts || !Array.isArray(facts) || facts.length === 0) {
+      return NextResponse.json(
+        { error: "facts array is required and must not be empty" },
+        { status: 400 }
+      );
+    }
+
+    const result = storeExtractedFacts(facts, sourceDocId, extractionSource);
+
+    return NextResponse.json({
+      ok: true,
+      ...result,
+      total: facts.length,
+    });
+  } catch (err) {
+    console.error("POST /api/memory/items error:", err);
+    return NextResponse.json(
+      { error: "Failed to store memory items" },
+      { status: 500 }
+    );
+  }
+}

package/mission-control/src/app/api/memory/list/route.ts

@@ -0,0 +1,48 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getDb } from "@/lib/db";
+import { memoryDocs } from "@/lib/db/schema";
+import { eq, desc } from "drizzle-orm";
+
+/**
+ * GET /api/memory/list?source=daily_log
+ * List all indexed memory documents (without full content).
+ * Sorted by date desc, then modified_at desc.
+ */
+export async function GET(request: NextRequest) {
+  try {
+    const db = getDb();
+    const source = request.nextUrl.searchParams.get("source");
+
+    const query = db
+      .select({
+        id: memoryDocs.id,
+        source: memoryDocs.source,
+        category: memoryDocs.category,
+        filePath: memoryDocs.filePath,
+        title: memoryDocs.title,
+        date: memoryDocs.date,
+        modifiedAt: memoryDocs.modifiedAt,
+      })
+      .from(memoryDocs);
+
+    let rows;
+    if (source) {
+      rows = query
+        .where(eq(memoryDocs.source, source))
+        .orderBy(desc(memoryDocs.date), desc(memoryDocs.modifiedAt))
+        .all();
+    } else {
+      rows = query
+        .orderBy(desc(memoryDocs.date), desc(memoryDocs.modifiedAt))
+        .all();
+    }
+
+    return NextResponse.json({ docs: rows, total: rows.length });
+  } catch (err) {
+    console.error("GET /api/memory/list error:", err);
+    return NextResponse.json(
+      { error: "Failed to list memory docs" },
+      { status: 500 }
+    );
+  }
+}

package/mission-control/src/app/api/memory/retrieve/route.ts

@@ -0,0 +1,51 @@
+import { NextRequest, NextResponse } from "next/server";
+import { tieredSearch, formatInjectionBlock, getMemoryInjection } from "@/lib/memory/retrieval";
+
+/**
+ * GET /api/memory/retrieve?q=query&limit=10&format=block
+ *
+ * Tiered memory retrieval:
+ * - Tier 1: Category summaries
+ * - Tier 2: Memory items (FTS5)
+ * - Tier 3: Full docs (FTS5)
+ *
+ * Add &format=block to get the formatted injection block (for agent context).
+ * Default returns raw results array.
+ */
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = request.nextUrl;
+    const query = searchParams.get("q");
+    const limit = Math.min(parseInt(searchParams.get("limit") || "10", 10), 50);
+    const format = searchParams.get("format");
+
+    if (!query || query.trim().length < 2) {
+      return NextResponse.json(
+        { error: "Query parameter 'q' is required (min 2 chars)" },
+        { status: 400 }
+      );
+    }
+
+    if (format === "block") {
+      const { block, results } = getMemoryInjection(query, limit);
+      return NextResponse.json({ block, resultCount: results.length });
+    }
+
+    const results = tieredSearch(query, limit);
+    return NextResponse.json({
+      results,
+      total: results.length,
+      tiers: {
+        t1: results.filter((r) => r.tier === 1).length,
+        t2: results.filter((r) => r.tier === 2).length,
+        t3: results.filter((r) => r.tier === 3).length,
+      },
+    });
+  } catch (err) {
+    console.error("GET /api/memory/retrieve error:", err);
+    return NextResponse.json(
+      { error: "Failed to retrieve memories" },
+      { status: 500 }
+    );
+  }
+}

package/mission-control/src/app/api/memory/search/route.ts

@@ -0,0 +1,143 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getRawDb } from "@/lib/db";
+
+/**
+ * Score decay: time-weighted relevance scoring.
+ * Recent facts beat old facts at equal relevance.
+ * Formula: finalScore = relevance × exp(-decayRate × daysOld)
+ */
+function applyScoreDecay(
+  rows: Array<Record<string, unknown>>,
+  decayRate = 0.01
+): Array<Record<string, unknown>> {
+  const now = Date.now();
+  return rows.map((row) => {
+    const dateStr = (row.date as string) || (row.modifiedAt as string);
+    const daysOld = dateStr
+      ? (now - new Date(dateStr).getTime()) / (1000 * 60 * 60 * 24)
+      : 30; // default 30 days if no date
+    const rawRank = row.rank as number; // FTS5 rank is negative (lower = better)
+    const relevance = -rawRank; // flip so higher = better
+    const decayedScore = relevance * Math.exp(-decayRate * daysOld);
+    return { ...row, decayedScore, daysOld: Math.round(daysOld) };
+  });
+}
+
+/**
+ * Expand search query with synonyms and related terms.
+ * Lightweight keyword expansion — no LLM call needed for dashboard use.
+ * Daedalus does deeper semantic rewriting inline during his own searches.
+ */
+function expandQuery(query: string): string {
+  // Split into terms and add OR variants for common patterns
+  const terms = query.trim().split(/\s+/);
+  if (terms.length === 1) {
+    // Single term: use prefix matching
+    return `"${query.replace(/"/g, '""')}"*`;
+  }
+  // Multi-term: quote as phrase + add individual terms with OR for broader recall
+  const phrase = `"${query.replace(/"/g, '""')}"`;
+  const individual = terms.map((t) => `"${t.replace(/"/g, '""')}"*`).join(" OR ");
+  return `(${phrase}) OR (${individual})`;
+}
+
+/**
+ * GET /api/memory/search?q=term&source=daily_log&category=preferences&limit=20&offset=0&decay=true
+ * Full-text search across indexed memory using FTS5.
+ * Supports score decay (time-weighted relevance) via &decay=true (default: true).
+ * Uses raw SQLite for FTS5 MATCH + snippet() since Drizzle doesn't support FTS5.
+ */
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = request.nextUrl;
+    const query = searchParams.get("q");
+    const source = searchParams.get("source");
+    const category = searchParams.get("category");
+    const limit = Math.min(parseInt(searchParams.get("limit") || "20", 10), 100);
+    const offset = parseInt(searchParams.get("offset") || "0", 10);
+    const useDecay = searchParams.get("decay") !== "false"; // default: true
+    const decayRate = parseFloat(searchParams.get("decay_rate") || "0.01");
+
+    if (!query || query.trim().length === 0) {
+      return NextResponse.json(
+        { error: "Query parameter 'q' is required" },
+        { status: 400 }
+      );
+    }
+
+    const raw = getRawDb();
+
+    // Build WHERE conditions for the joined memory_docs table
+    const conditions: string[] = [];
+    const params: (string | number)[] = [];
+
+    // FTS5 MATCH condition with query expansion
+    conditions.push("memory_fts MATCH ?");
+    params.push(expandQuery(query));
+
+    if (source) {
+      conditions.push("md.source = ?");
+      params.push(source);
+    }
+    if (category) {
+      conditions.push("md.category = ?");
+      params.push(category);
+    }
+
+    const whereClause = conditions.join(" AND ");
+
+    // Count total matches
+    const countSql = `
+      SELECT COUNT(*) as total
+      FROM memory_fts
+      JOIN memory_docs md ON md.id = memory_fts.rowid
+      WHERE ${whereClause}
+    `;
+    const countResult = raw.prepare(countSql).get(...params) as {
+      total: number;
+    };
+
+    // Fetch results — grab more than needed if decay is on (re-ranking may shuffle order)
+    const fetchLimit = useDecay ? Math.min(limit * 3, 100) : limit;
+    const selectSql = `
+      SELECT
+        md.id,
+        md.source,
+        md.category,
+        md.file_path AS filePath,
+        md.title,
+        md.date,
+        md.modified_at AS modifiedAt,
+        snippet(memory_fts, 1, '<mark>', '</mark>', '...', 48) AS excerpt,
+        rank
+      FROM memory_fts
+      JOIN memory_docs md ON md.id = memory_fts.rowid
+      WHERE ${whereClause}
+      ORDER BY rank
+      LIMIT ? OFFSET ?
+    `;
+    params.push(fetchLimit, offset);
+    let rows = raw.prepare(selectSql).all(...params) as Array<Record<string, unknown>>;
+
+    // Apply score decay if enabled — re-rank by time-weighted relevance
+    if (useDecay && rows.length > 0) {
+      rows = applyScoreDecay(rows, decayRate);
+      rows.sort(
+        (a, b) => (b.decayedScore as number) - (a.decayedScore as number)
+      );
+      rows = rows.slice(0, limit);
+    }
+
+    return NextResponse.json({
+      results: rows,
+      total: countResult.total,
+      limit,
+      offset,
+    });
+  } catch (err) {
+    console.error("GET /api/memory/search error:", err);
+    const message =
+      err instanceof Error ? err.message : "Failed to search memory";
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}

package/mission-control/src/app/api/memory/sync/route.ts

@@ -0,0 +1,23 @@
+import { NextResponse } from "next/server";
+import { getDb } from "@/lib/db";
+import { indexAllMemory } from "@/lib/sync/memory";
+
+/**
+ * POST /api/memory/sync
+ * Force re-index all memory sources from disk into SQLite + FTS5.
+ * Returns { indexed, updated, removed }.
+ */
+export async function POST() {
+  try {
+    const db = getDb();
+    const stats = indexAllMemory(db);
+
+    return NextResponse.json(stats);
+  } catch (err) {
+    console.error("POST /api/memory/sync error:", err);
+    return NextResponse.json(
+      { error: "Failed to sync memory" },
+      { status: 500 }
+    );
+  }
+}

package/mission-control/src/app/api/memory/wikilinks/route.ts

@@ -0,0 +1,75 @@
+import { NextResponse } from "next/server";
+import { getDb } from "@/lib/db";
+import { memoryDocs } from "@/lib/db/schema";
+import {
+  extractAllReferences,
+  buildResolutionMaps,
+} from "@/lib/memory/wikilinks";
+
+/**
+ * GET /api/memory/wikilinks
+ * Compute the document-level cross-reference graph from all indexed memory_docs.
+ * Auto-detects: [[wikilinks]], task IDs (ARCANE-M01, T-xxx), file path mentions.
+ */
+export async function GET() {
+  try {
+    const db = getDb();
+
+    const docs = db
+      .select({
+        id: memoryDocs.id,
+        filePath: memoryDocs.filePath,
+        title: memoryDocs.title,
+        source: memoryDocs.source,
+        category: memoryDocs.category,
+        content: memoryDocs.content,
+      })
+      .from(memoryDocs)
+      .all();
+
+    const maps = buildResolutionMaps(docs);
+
+    const linkCounts = new Map<string, number>();
+    const links: Array<{ source: string; target: string }> = [];
+    const seenEdges = new Set<string>();
+
+    for (const doc of docs) {
+      const refs = extractAllReferences(doc.content, maps, doc.filePath);
+      for (const target of refs) {
+        const edgeKey = `${doc.filePath}::${target}`;
+        if (!seenEdges.has(edgeKey)) {
+          seenEdges.add(edgeKey);
+          links.push({ source: doc.filePath, target });
+          linkCounts.set(
+            doc.filePath,
+            (linkCounts.get(doc.filePath) || 0) + 1
+          );
+          linkCounts.set(target, (linkCounts.get(target) || 0) + 1);
+        }
+      }
+    }
+
+    const nodes = docs.map((d) => ({
+      id: d.filePath,
+      title:
+        d.title ||
+        d.filePath.split("/").pop()?.replace(/\.md$/, "") ||
+        d.filePath,
+      source: d.source,
+      category: d.category,
+      linkCount: linkCounts.get(d.filePath) || 0,
+    }));
+
+    return NextResponse.json({
+      nodes,
+      links,
+      stats: { nodeCount: nodes.length, linkCount: links.length },
+    });
+  } catch (err) {
+    console.error("GET /api/memory/wikilinks error:", err);
+    return NextResponse.json(
+      { error: "Failed to compute wikilink graph" },
+      { status: 500 }
+    );
+  }
+}

package/mission-control/src/app/api/mesh/events/route.ts

@@ -0,0 +1,67 @@
+import { getNats, sc } from "@/lib/nats";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * SSE endpoint that subscribes to mesh.events.> and pushes to connected browsers.
+ * Falls back gracefully if NATS is unavailable.
+ */
+export async function GET() {
+  const nc = await getNats();
+  if (!nc) {
+    return new Response("NATS unavailable", { status: 503 });
+  }
+
+  const sub = nc.subscribe("mesh.events.>");
+  let closed = false;
+
+  const stream = new ReadableStream({
+    async start(controller) {
+      const encoder = new TextEncoder();
+
+      // Send initial keepalive
+      controller.enqueue(encoder.encode(": connected\n\n"));
+
+      // Keepalive every 30s to prevent proxy/browser timeout
+      const keepalive = setInterval(() => {
+        if (!closed) {
+          try {
+            controller.enqueue(encoder.encode(": keepalive\n\n"));
+          } catch {
+            // controller closed
+          }
+        }
+      }, 30000);
+
+      try {
+        for await (const msg of sub) {
+          if (closed) break;
+          try {
+            const data = sc.decode(msg.data);
+            const eventType = msg.subject.replace("mesh.events.", "");
+            controller.enqueue(
+              encoder.encode(`event: ${eventType}\ndata: ${data}\n\n`)
+            );
+          } catch {
+            // skip malformed messages
+          }
+        }
+      } finally {
+        clearInterval(keepalive);
+      }
+    },
+    cancel() {
+      closed = true;
+      sub.unsubscribe();
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache, no-transform",
+      Connection: "keep-alive",
+      "X-Accel-Buffering": "no", // disable nginx buffering
+    },
+  });
+}