openclaw-node-harness 2.0.0

package/mission-control/src/lib/sync/memory.ts

@@ -0,0 +1,224 @@
+import fs from "fs";
+import path from "path";
+import { eq } from "drizzle-orm";
+import { memoryDocs } from "@/lib/db/schema";
+import { MEMORY_DIR, MEMORY_MD, CLAWVAULT_INDEX, LORE_DIRS } from "@/lib/config";
+import { parseDailyLog, listDailyLogs } from "@/lib/parsers/daily-log";
+import { parseVaultDocument, listVaultDocuments } from "@/lib/parsers/clawvault-doc";
+import { parseMemoryMd } from "@/lib/parsers/memory-md";
+
+type DrizzleDb = ReturnType<typeof import("@/lib/db")["getDb"]>;
+
+interface SyncStats {
+  indexed: number;
+  updated: number;
+  removed: number;
+}
+
+/**
+ * Indexes all memory sources (daily logs, MEMORY.md, ClawVault docs)
+ * into the memory_docs table. Compares file mtime to skip unchanged files.
+ * Removes rows for files that no longer exist on disk.
+ */
+export function indexAllMemory(db: DrizzleDb): SyncStats {
+  const stats: SyncStats = { indexed: 0, updated: 0, removed: 0 };
+  const seenPaths = new Set<string>();
+
+  // --- Daily Logs ---
+  try {
+    const logFiles = listDailyLogs(MEMORY_DIR);
+    for (const filePath of logFiles) {
+      seenPaths.add(filePath);
+      if (skipIfUnchanged(db, filePath)) continue;
+
+      const entry = parseDailyLog(filePath);
+      const isUpdate = upsertDoc(db, {
+        source: "daily_log",
+        category: null,
+        filePath: entry.filePath,
+        title: entry.title,
+        date: entry.date,
+        frontmatter: null,
+        content: entry.content,
+        modifiedAt: entry.modifiedAt,
+      });
+      isUpdate ? stats.updated++ : stats.indexed++;
+    }
+  } catch {
+    // daily logs directory may not exist yet
+  }
+
+  // --- MEMORY.md ---
+  try {
+    if (fs.existsSync(MEMORY_MD)) {
+      seenPaths.add(MEMORY_MD);
+      if (!skipIfUnchanged(db, MEMORY_MD)) {
+        const mem = parseMemoryMd(MEMORY_MD);
+        const isUpdate = upsertDoc(db, {
+          source: "long_term_memory",
+          category: null,
+          filePath: mem.filePath,
+          title: mem.title,
+          date: null,
+          frontmatter: null,
+          content: mem.fullContent,
+          modifiedAt: mem.modifiedAt,
+        });
+        isUpdate ? stats.updated++ : stats.indexed++;
+      }
+    }
+  } catch {
+    // MEMORY.md may not exist
+  }
+
+  // --- ClawVault Documents ---
+  try {
+    if (fs.existsSync(CLAWVAULT_INDEX)) {
+      const entries = listVaultDocuments(CLAWVAULT_INDEX);
+      for (const entry of entries) {
+        seenPaths.add(entry.path);
+        if (skipIfUnchanged(db, entry.path)) continue;
+
+        const doc = parseVaultDocument(entry.path);
+        const isUpdate = upsertDoc(db, {
+          source: "clawvault",
+          category: doc.category || entry.category,
+          filePath: doc.filePath,
+          title: doc.title,
+          date: doc.date || null,
+          frontmatter: doc.frontmatter ? JSON.stringify(doc.frontmatter) : null,
+          content: doc.content,
+          modifiedAt: doc.modifiedAt,
+        });
+        isUpdate ? stats.updated++ : stats.indexed++;
+      }
+    }
+  } catch {
+    // ClawVault index may not exist
+  }
+
+  // --- Lore Knowledge Base ---
+  for (const loreDir of LORE_DIRS) {
+    try {
+      if (!fs.existsSync(loreDir)) continue;
+      const files = fs.readdirSync(loreDir).filter((f) => f.endsWith(".md"));
+
+      for (const filename of files) {
+        const filePath = path.join(loreDir, filename);
+        seenPaths.add(filePath);
+        if (skipIfUnchanged(db, filePath)) continue;
+
+        const stat = fs.statSync(filePath);
+        const content = fs.readFileSync(filePath, "utf-8");
+
+        // Extract title from first H1 or filename
+        const h1Match = content.match(/^#\s+(.+)/m);
+        const title = h1Match ? h1Match[1].trim() : filename.replace(/\.md$/, "");
+
+        // Derive category from parent dir name
+        const dirName = path.basename(loreDir); // "research", "canon", "drafts"
+
+        const isUpdate = upsertDoc(db, {
+          source: "lore",
+          category: dirName,
+          filePath,
+          title,
+          date: null,
+          frontmatter: null,
+          content,
+          modifiedAt: stat.mtime.toISOString(),
+        });
+        isUpdate ? stats.updated++ : stats.indexed++;
+      }
+    } catch {
+      // lore directory may not exist
+    }
+  }
+
+  // --- Remove rows for deleted files ---
+  const allDocs = db
+    .select({ id: memoryDocs.id, filePath: memoryDocs.filePath })
+    .from(memoryDocs)
+    .all();
+
+  for (const row of allDocs) {
+    if (!seenPaths.has(row.filePath)) {
+      db.delete(memoryDocs).where(eq(memoryDocs.id, row.id)).run();
+      stats.removed++;
+    }
+  }
+
+  return stats;
+}
+
+/**
+ * Returns true if the file's mtime matches what's already indexed,
+ * meaning we can skip re-indexing.
+ */
+function skipIfUnchanged(db: DrizzleDb, filePath: string): boolean {
+  if (!fs.existsSync(filePath)) return true;
+
+  const stat = fs.statSync(filePath);
+  const fileMtime = stat.mtime.toISOString();
+
+  const existing = db
+    .select({ modifiedAt: memoryDocs.modifiedAt })
+    .from(memoryDocs)
+    .where(eq(memoryDocs.filePath, filePath))
+    .get();
+
+  return existing?.modifiedAt === fileMtime;
+}
+
+interface DocInsert {
+  source: string;
+  category: string | null;
+  filePath: string;
+  title: string | null;
+  date: string | null;
+  frontmatter: string | null;
+  content: string;
+  modifiedAt: string | null;
+}
+
+/**
+ * Upserts a memory doc row. Returns true if it was an update (row existed).
+ */
+function upsertDoc(db: DrizzleDb, doc: DocInsert): boolean {
+  const existing = db
+    .select({ id: memoryDocs.id })
+    .from(memoryDocs)
+    .where(eq(memoryDocs.filePath, doc.filePath))
+    .get();
+
+  const now = new Date().toISOString();
+
+  db.insert(memoryDocs)
+    .values({
+      source: doc.source,
+      category: doc.category,
+      filePath: doc.filePath,
+      title: doc.title,
+      date: doc.date,
+      frontmatter: doc.frontmatter,
+      content: doc.content,
+      modifiedAt: doc.modifiedAt,
+      indexedAt: now,
+    })
+    .onConflictDoUpdate({
+      target: memoryDocs.filePath,
+      set: {
+        source: doc.source,
+        category: doc.category,
+        title: doc.title,
+        date: doc.date,
+        frontmatter: doc.frontmatter,
+        content: doc.content,
+        modifiedAt: doc.modifiedAt,
+        indexedAt: now,
+      },
+    })
+    .run();
+
+  return !!existing;
+}

package/mission-control/src/lib/sync/tasks.ts

@@ -0,0 +1,271 @@
+import fs from "fs";
+import path from "path";
+import { eq } from "drizzle-orm";
+import { tasks } from "@/lib/db/schema";
+import { ACTIVE_TASKS_MD } from "@/lib/config";
+import {
+  parseTasksMarkdown,
+  serializeTasksMarkdown,
+  statusToKanban,
+} from "@/lib/parsers/task-markdown";
+
+type DrizzleDb = ReturnType<typeof import("@/lib/db")["getDb"]>;
+
+/* ------------------------------------------------------------------ */
+/*  Mtime tracking — only re-sync from markdown when the file changes */
+/* ------------------------------------------------------------------ */
+
+let lastKnownMtime = 0;
+let lastWriteMtime = 0; // mtime right after WE wrote the file
+let lastImportTime = 0; // when we last ran a full import
+
+// Debounce: bridge writes every 10s, memory-daemon every 3s — each changes
+// mtime and triggers a full parse+upsert of every task. 5s cooldown prevents
+// redundant re-imports during active mesh operations.
+const MIN_REIMPORT_INTERVAL_MS = 5000;
+
+/**
+ * Check if active-tasks.md was modified externally (by Daedalus/user)
+ * since we last read or wrote it.
+ */
+function markdownChangedExternally(): boolean {
+  if (!fs.existsSync(ACTIVE_TASKS_MD)) return false;
+
+  // Debounce: don't re-import if we just imported less than 5s ago
+  if (Date.now() - lastImportTime < MIN_REIMPORT_INTERVAL_MS) return false;
+
+  const stat = fs.statSync(ACTIVE_TASKS_MD);
+  const mtime = stat.mtimeMs;
+
+  // If the mtime matches what we set after our last write, skip.
+  // This prevents re-importing our own writes.
+  // Use tolerance window for cross-platform filesystem compatibility.
+  if (Math.abs(mtime - lastWriteMtime) < 50) return false;
+
+  if (Math.abs(mtime - lastKnownMtime) > 50) {
+    lastKnownMtime = mtime;
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Sync tasks from active-tasks.md into SQLite.
+ * ONLY called when the file has been modified externally.
+ * Merges markdown state into DB without blindly overwriting DB-only fields.
+ */
+export function syncTasksFromMarkdown(db: DrizzleDb): void {
+  if (!fs.existsSync(ACTIVE_TASKS_MD)) return;
+
+  lastImportTime = Date.now(); // stamp BEFORE work — prevents re-entry during long imports
+
+  const raw = fs.readFileSync(ACTIVE_TASKS_MD, "utf-8");
+  const parsed = parseTasksMarkdown(raw);
+  const now = new Date().toISOString();
+
+  const incomingIds = new Set<string>();
+
+  for (const task of parsed) {
+    incomingIds.add(task.id);
+
+    // Check if task already exists in DB
+    const existing = db
+      .select()
+      .from(tasks)
+      .where(eq(tasks.id, task.id))
+      .get();
+
+    if (existing) {
+      // MERGE: update fields from markdown but preserve DB-authoritative fields
+      // Done-gate: if markdown says "done" but task requires approval, redirect to "review"
+      let effectiveStatus = task.status;
+      if (task.status === "done" && existing.needsApproval === 1 && existing.status !== "done") {
+        effectiveStatus = "waiting-user";
+      }
+      // If status changed in markdown, update kanbanColumn to match
+      const statusChanged = existing.status !== effectiveStatus;
+      const update: Record<string, unknown> = {
+        title: task.title,
+        status: effectiveStatus,
+        owner: task.owner || null,
+        successCriteria: task.successCriteria.length
+          ? JSON.stringify(task.successCriteria)
+          : null,
+        artifacts: task.artifacts.length
+          ? JSON.stringify(task.artifacts)
+          : null,
+        nextAction: task.nextAction || null,
+        scheduledDate: task.scheduledDate || null,
+        project: task.project || null,
+        type: task.type || "task",
+        parentId: task.parentId || null,
+        startDate: task.startDate || null,
+        endDate: task.endDate || null,
+        color: task.color || null,
+        description: task.description || null,
+        needsApproval: task.needsApproval ? 1 : 0,
+        triggerKind: task.triggerKind || "none",
+        triggerAt: task.triggerAt || null,
+        triggerCron: task.triggerCron || null,
+        triggerTz: task.triggerTz || "America/Montreal",
+        isRecurring: task.isRecurring ? 1 : 0,
+        capacityClass: task.capacityClass || "normal",
+        autoPriority: task.autoPriority || 0,
+        // Mesh execution fields
+        execution: task.execution || null,
+        meshTaskId: task.meshTaskId || null,
+        meshNode: task.meshNode || null,
+        metric: task.metric || null,
+        budgetMinutes: task.budgetMinutes || 30,
+        scope: task.scope?.length ? JSON.stringify(task.scope) : null,
+        updatedAt: task.updatedAt || now,
+      };
+
+      // Only update kanbanColumn if status actually changed in the markdown
+      if (statusChanged) {
+        update.kanbanColumn = statusToKanban(effectiveStatus);
+      }
+      // Otherwise, preserve the existing kanbanColumn (user may have dragged it)
+
+      db.update(tasks).set(update).where(eq(tasks.id, task.id)).run();
+    } else {
+      // INSERT: new task from markdown
+      db.insert(tasks)
+        .values({
+          id: task.id,
+          title: task.title,
+          status: task.status,
+          kanbanColumn: statusToKanban(task.status),
+          owner: task.owner || null,
+          successCriteria: task.successCriteria.length
+            ? JSON.stringify(task.successCriteria)
+            : null,
+          artifacts: task.artifacts.length
+            ? JSON.stringify(task.artifacts)
+            : null,
+          nextAction: task.nextAction || null,
+          scheduledDate: task.scheduledDate || null,
+          project: task.project || null,
+          type: task.type || "task",
+          parentId: task.parentId || null,
+          startDate: task.startDate || null,
+          endDate: task.endDate || null,
+          color: task.color || null,
+          description: task.description || null,
+          needsApproval: task.needsApproval ? 1 : 0,
+          triggerKind: task.triggerKind || "none",
+          triggerAt: task.triggerAt || null,
+          triggerCron: task.triggerCron || null,
+          triggerTz: task.triggerTz || "America/Montreal",
+          isRecurring: task.isRecurring ? 1 : 0,
+          capacityClass: task.capacityClass || "normal",
+          autoPriority: task.autoPriority || 0,
+          // Mesh execution fields
+          execution: task.execution || null,
+          meshTaskId: task.meshTaskId || null,
+          meshNode: task.meshNode || null,
+          metric: task.metric || null,
+          budgetMinutes: task.budgetMinutes || 30,
+          scope: task.scope?.length ? JSON.stringify(task.scope) : null,
+          updatedAt: task.updatedAt || now,
+          createdAt: now,
+        })
+        .run();
+    }
+  }
+
+  // Remove tasks that no longer exist in the markdown —
+  // but PRESERVE roadmap/pipeline tasks (project, phase, pipeline types)
+  // and any tasks tagged with a project (they live in the DB, not markdown).
+  const allDbTasks = db
+    .select({ id: tasks.id, type: tasks.type, project: tasks.project })
+    .from(tasks)
+    .all();
+  for (const row of allDbTasks) {
+    if (row.id === "__LIVE_SESSION__") continue;
+    // Preserve hierarchy nodes (project, phase, pipeline) — they're roadmap-only
+    if (row.type === "project" || row.type === "phase" || row.type === "pipeline") continue;
+    // Preserve tasks owned by a project (imported via pipeline, not markdown-managed)
+    if (row.project) continue;
+    if (!incomingIds.has(row.id)) {
+      db.delete(tasks).where(eq(tasks.id, row.id)).run();
+    }
+  }
+}
+
+/**
+ * Conditionally sync from markdown — only if file changed externally.
+ * This is what GET /api/tasks should call instead of unconditional sync.
+ */
+export function syncTasksFromMarkdownIfChanged(db: DrizzleDb): void {
+  if (markdownChangedExternally()) {
+    syncTasksFromMarkdown(db);
+  }
+}
+
+/**
+ * Sync tasks from SQLite back to active-tasks.md.
+ * Reads all tasks from the DB, converts to parsed format,
+ * serializes to markdown, and writes atomically (tmp + rename).
+ * Tracks the mtime after write to avoid re-importing our own changes.
+ */
+export function syncTasksToMarkdown(db: DrizzleDb): void {
+  const allTasks = db
+    .select()
+    .from(tasks)
+    .orderBy(tasks.sortOrder, tasks.id)
+    .all();
+
+  // Filter out the live session task — it's synthetic
+  const parsed = allTasks
+    .filter((t) => t.id !== "__LIVE_SESSION__")
+    .map((t) => ({
+      id: t.id,
+      title: t.title,
+      status: t.status,
+      owner: t.owner || "",
+      successCriteria: t.successCriteria ? JSON.parse(t.successCriteria) : [],
+      artifacts: t.artifacts ? JSON.parse(t.artifacts) : [],
+      nextAction: t.nextAction || "",
+      scheduledDate: t.scheduledDate || null,
+      project: t.project || null,
+      type: t.type || null,
+      parentId: t.parentId || null,
+      startDate: t.startDate || null,
+      endDate: t.endDate || null,
+      color: t.color || null,
+      description: t.description || null,
+      needsApproval: !!t.needsApproval,
+      triggerKind: t.triggerKind || "none",
+      triggerAt: t.triggerAt || null,
+      triggerCron: t.triggerCron || null,
+      triggerTz: t.triggerTz || "America/Montreal",
+      isRecurring: !!t.isRecurring,
+      capacityClass: t.capacityClass || "normal",
+      autoPriority: t.autoPriority || 0,
+      // Mesh execution fields — MUST be preserved on DB→markdown round-trip
+      execution: t.execution || null,
+      meshTaskId: t.meshTaskId || null,
+      meshNode: t.meshNode || null,
+      metric: t.metric || null,
+      budgetMinutes: t.budgetMinutes || 30,
+      scope: t.scope ? JSON.parse(t.scope) : [],
+      updatedAt: t.updatedAt,
+    }));
+
+  const markdown = serializeTasksMarkdown(parsed);
+
+  // Atomic write: write to .tmp, then rename over original
+  const tmpPath = ACTIVE_TASKS_MD + ".tmp";
+  const dir = path.dirname(ACTIVE_TASKS_MD);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(tmpPath, markdown, "utf-8");
+  fs.renameSync(tmpPath, ACTIVE_TASKS_MD);
+
+  // Record mtime of our own write so we don't re-import it
+  const stat = fs.statSync(ACTIVE_TASKS_MD);
+  lastWriteMtime = stat.mtimeMs;
+  lastKnownMtime = stat.mtimeMs;
+}

package/mission-control/src/lib/tts/edge.ts

@@ -0,0 +1,31 @@
+import type { TtsProvider, TtsRequest, TtsResponse } from "./types";
+
+export function createEdgeTtsProvider(): TtsProvider {
+  return {
+    name: "edge",
+    async synthesize(req: TtsRequest): Promise<TtsResponse> {
+      // Dynamic import — @andresaya/edge-tts is server-side only (uses Node WebSocket)
+      const { EdgeTTS } = await import("@andresaya/edge-tts");
+
+      const client = new EdgeTTS();
+
+      // rate: convert multiplier (1.0 = normal) to percentage offset
+      const rate = req.rate ? Math.round((req.rate - 1) * 100) : 0;
+      // pitch: pass through as Hz offset
+      const pitch = req.pitch ?? 0;
+
+      await client.synthesize(
+        req.text,
+        req.voice || "en-GB-SoniaNeural",
+        { rate, pitch }
+      );
+
+      const audio = client.toBuffer();
+      if (!audio || audio.length === 0) {
+        throw new Error("Edge TTS returned no audio data");
+      }
+
+      return { audio, contentType: "audio/mp3" };
+    },
+  };
+}

package/mission-control/src/lib/tts/google.ts

@@ -0,0 +1,78 @@
+import type { TtsProvider, TtsRequest, TtsResponse } from "./types";
+
+const GEMINI_TTS_ENDPOINT =
+  "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash-preview-tts:generateContent";
+
+// Wrap raw PCM (16-bit mono 24kHz) in a WAV header so browsers can decode it
+function pcmToWav(pcm: Buffer): Buffer {
+  const sampleRate = 24000;
+  const numChannels = 1;
+  const bitsPerSample = 16;
+  const byteRate = sampleRate * numChannels * (bitsPerSample / 8);
+  const blockAlign = numChannels * (bitsPerSample / 8);
+  const header = Buffer.alloc(44);
+
+  header.write("RIFF", 0);
+  header.writeUInt32LE(36 + pcm.length, 4);
+  header.write("WAVE", 8);
+  header.write("fmt ", 12);
+  header.writeUInt32LE(16, 16);         // chunk size
+  header.writeUInt16LE(1, 20);          // PCM format
+  header.writeUInt16LE(numChannels, 22);
+  header.writeUInt32LE(sampleRate, 24);
+  header.writeUInt32LE(byteRate, 28);
+  header.writeUInt16LE(blockAlign, 32);
+  header.writeUInt16LE(bitsPerSample, 34);
+  header.write("data", 36);
+  header.writeUInt32LE(pcm.length, 40);
+
+  return Buffer.concat([header, pcm]);
+}
+
+export function createGoogleTtsProvider(): TtsProvider {
+  return {
+    name: "google",
+    async synthesize(req: TtsRequest): Promise<TtsResponse> {
+      const apiKey = process.env.GEMINI_API_KEY;
+      if (!apiKey) {
+        throw new Error("GEMINI_API_KEY not configured");
+      }
+
+      const response = await fetch(GEMINI_TTS_ENDPOINT, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-goog-api-key": apiKey,
+        },
+        body: JSON.stringify({
+          contents: [{ parts: [{ text: req.tone ? `Say in ${req.tone}: ${req.text}` : req.text }] }],
+          generationConfig: {
+            responseModalities: ["AUDIO"],
+            speechConfig: {
+              voiceConfig: {
+                prebuiltVoiceConfig: {
+                  voiceName: req.voice || "Kore",
+                },
+              },
+            },
+          },
+        }),
+      });
+
+      if (!response.ok) {
+        const err = await response.text();
+        throw new Error(`Gemini TTS error ${response.status}: ${err}`);
+      }
+
+      const data = await response.json();
+      const pcmBase64 = data?.candidates?.[0]?.content?.parts?.[0]?.inlineData?.data;
+      if (!pcmBase64) {
+        throw new Error("Gemini TTS returned no audio data");
+      }
+
+      const pcm = Buffer.from(pcmBase64, "base64");
+      const wav = pcmToWav(pcm);
+      return { audio: wav, contentType: "audio/wav" };
+    },
+  };
+}

package/mission-control/src/lib/tts/index.ts

@@ -0,0 +1,39 @@
+import type { TtsProvider, TtsRequest, TtsResponse } from "./types";
+import { createGoogleTtsProvider } from "./google";
+import { createEdgeTtsProvider } from "./edge";
+
+export type { TtsRequest, TtsResponse, TtsProvider } from "./types";
+
+const providers: Record<string, () => TtsProvider> = {
+  google: createGoogleTtsProvider,
+  edge: createEdgeTtsProvider,
+};
+
+export function getProvider(name: "google" | "edge"): TtsProvider {
+  const factory = providers[name];
+  if (!factory) throw new Error(`Unknown TTS provider: ${name}`);
+  return factory();
+}
+
+export interface SynthesisResult extends TtsResponse {
+  actualProvider: string;
+  fallbackReason?: string;
+}
+
+export async function synthesizeWithFallback(
+  req: TtsRequest,
+  preferred: "google" | "edge" = "google"
+): Promise<SynthesisResult> {
+  try {
+    const result = await getProvider(preferred).synthesize(req);
+    return { ...result, actualProvider: preferred };
+  } catch (err) {
+    const fallback = preferred === "google" ? "edge" : "google";
+    const reason = err instanceof Error ? err.message : String(err);
+    console.warn(
+      `TTS provider "${preferred}" failed, falling back to "${fallback}": ${reason}`
+    );
+    const result = await getProvider(fallback).synthesize(req);
+    return { ...result, actualProvider: fallback, fallbackReason: reason };
+  }
+}

package/mission-control/src/lib/tts/types.ts

@@ -0,0 +1,18 @@
+export interface TtsRequest {
+  text: string;
+  voice?: string;
+  rate?: number;
+  pitch?: number;
+  /** Natural language tone directive for Gemini TTS (e.g. "asmr whisper deep tone") */
+  tone?: string;
+}
+
+export interface TtsResponse {
+  audio: Buffer;
+  contentType: string;
+}
+
+export interface TtsProvider {
+  name: string;
+  synthesize(req: TtsRequest): Promise<TtsResponse>;
+}