openclaw-node-harness 2.0.0

package/mission-control/src/app/api/souls/[id]/prompt/route.ts

@@ -0,0 +1,205 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getDb } from "@/lib/db";
+import { soulSpawns } from "@/lib/db/schema";
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+
+const SOULS_DIR = path.join(os.homedir(), ".openclaw/souls");
+const HANDOFFS_DIR = path.join(
+  os.homedir(),
+  ".openclaw/workspace/memory-vault/handoffs"
+);
+
+interface PromptRequest {
+  taskId?: string;
+  extraContext?: string;
+}
+
+interface Gene {
+  id: string;
+  category: string;
+  signal: string;
+  preconditions?: string[];
+  strategy?: string[];
+}
+
+function determineSubagentType(tools: string[]): string {
+  const writableTools = ["Write", "Edit", "Bash"];
+  if (tools.some((t) => writableTools.includes(t))) {
+    return "general-purpose";
+  }
+  return "Explore";
+}
+
+// POST /api/souls/:id/prompt — Generate soul-enriched preamble for Task tool
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  try {
+    const { id: soulId } = await params;
+    const body: PromptRequest = await request.json();
+
+    const soulDir = path.join(SOULS_DIR, soulId);
+
+    // Verify soul exists
+    try {
+      await fs.access(soulDir);
+    } catch {
+      return NextResponse.json({ error: "Soul not found" }, { status: 404 });
+    }
+
+    const sections: string[] = [];
+
+    // 1. Identity (SOUL.md)
+    try {
+      const soulMd = await fs.readFile(
+        path.join(soulDir, "SOUL.md"),
+        "utf-8"
+      );
+      sections.push("# Soul Identity\n\n" + soulMd);
+    } catch {
+      // No SOUL.md
+    }
+
+    // 2. Principles (PRINCIPLES.md)
+    try {
+      const principles = await fs.readFile(
+        path.join(soulDir, "PRINCIPLES.md"),
+        "utf-8"
+      );
+      sections.push("# Decision Principles\n\n" + principles);
+    } catch {
+      // No PRINCIPLES.md
+    }
+
+    // 3. Learned genes (evolution/genes.json)
+    interface SoulPermissions {
+      memory?: Record<string, boolean | string>;
+      restrictedActions?: string[];
+    }
+    let capabilities: { tools: string[]; permissions?: SoulPermissions } = { tools: [] };
+    try {
+      const genesRaw = await fs.readFile(
+        path.join(soulDir, "evolution", "genes.json"),
+        "utf-8"
+      );
+      const genesData = JSON.parse(genesRaw);
+      const genes: Gene[] = genesData.genes || [];
+
+      if (genes.length > 0) {
+        let genesSection = "# Learned Patterns (apply these during analysis)\n\n";
+        for (const gene of genes) {
+          genesSection += `## ${gene.id}\n`;
+          genesSection += `**Category:** ${gene.category}\n`;
+          genesSection += `**Signal:** ${gene.signal}\n`;
+          if (gene.preconditions?.length) {
+            genesSection += "**Preconditions:**\n";
+            for (const p of gene.preconditions) {
+              genesSection += `  - ${p}\n`;
+            }
+          }
+          if (gene.strategy?.length) {
+            genesSection += "**Strategy:**\n";
+            for (const s of gene.strategy) {
+              genesSection += `  1. ${s}\n`;
+            }
+          }
+          genesSection += "\n";
+        }
+        sections.push(genesSection);
+      }
+    } catch {
+      // No genes
+    }
+
+    // 4. Capabilities & constraints
+    try {
+      const capsRaw = await fs.readFile(
+        path.join(soulDir, "capabilities.json"),
+        "utf-8"
+      );
+      capabilities = JSON.parse(capsRaw);
+      const perms = capabilities.permissions || {};
+      const memory = perms.memory || {};
+      const restricted = perms.restrictedActions || [];
+
+      let constraintSection = "# Operational Constraints\n\n";
+
+      if (Object.keys(memory).length > 0) {
+        constraintSection += "## Memory Access\n";
+        for (const [k, v] of Object.entries(memory)) {
+          constraintSection += `- **${k}:** ${JSON.stringify(v)}\n`;
+        }
+        constraintSection += "\n";
+      }
+
+      if (restricted.length > 0) {
+        constraintSection += "## Restricted Actions (DO NOT execute these)\n";
+        for (const r of restricted) {
+          constraintSection += `- ${r}\n`;
+        }
+        constraintSection += "\n";
+      }
+
+      constraintSection += "## Available Tools\n";
+      constraintSection += (capabilities.tools || []).join(", ") + "\n";
+
+      sections.push(constraintSection);
+    } catch {
+      // No capabilities.json
+    }
+
+    // 5. Handoff context
+    if (body.taskId) {
+      try {
+        const handoffDoc = await fs.readFile(
+          path.join(HANDOFFS_DIR, `${body.taskId}-handoff.md`),
+          "utf-8"
+        );
+        sections.push("# Task Handoff Context\n\n" + handoffDoc);
+      } catch {
+        // No handoff doc for this task
+      }
+    }
+
+    // 6. Extra context
+    if (body.extraContext) {
+      sections.push("# Additional Context\n\n" + body.extraContext);
+    }
+
+    // 7. Completion protocol
+    sections.push(
+      "# Completion Protocol\n\n" +
+        "- When done: report what was accomplished concisely\n" +
+        "- If blocked: surface the blocker immediately — do not spiral or guess\n" +
+        "- Do not add scope beyond what was asked\n" +
+        "- Prefer editing existing files over creating new ones\n" +
+        "- Security-first: no secrets in output, no destructive commands without confirmation"
+    );
+
+    const preamble = sections.join("\n\n---\n\n");
+    const subagentType = determineSubagentType(capabilities.tools || []);
+
+    // Log spawn event
+    const db = getDb();
+    await db.insert(soulSpawns).values({
+      soulId,
+      taskId: body.taskId || null,
+      subagentType,
+    });
+
+    return NextResponse.json({
+      preamble,
+      subagentType,
+      soulId,
+    });
+  } catch (error) {
+    console.error("Failed to generate soul prompt:", error);
+    return NextResponse.json(
+      { error: "Failed to generate soul prompt" },
+      { status: 500 }
+    );
+  }
+}

package/mission-control/src/app/api/souls/[id]/propagate/route.ts

@@ -0,0 +1,146 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getDb } from "@/lib/db";
+import { soulEvolutionLog } from "@/lib/db/schema";
+import { eq } from "drizzle-orm";
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+
+const SOULS_DIR = path.join(os.homedir(), ".openclaw/souls");
+
+interface PropagateRequest {
+  sourceEventId: string;
+  targetSoulId: string;
+}
+
+// POST /api/souls/:id/propagate — Propagate an approved gene to another soul
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  try {
+    const { id: sourceSoulId } = await params;
+    const body: PropagateRequest = await request.json();
+    const { sourceEventId, targetSoulId } = body;
+
+    // Validate target soul exists
+    const targetSoulDir = path.join(SOULS_DIR, targetSoulId);
+    try {
+      await fs.access(targetSoulDir);
+    } catch {
+      return NextResponse.json(
+        { error: `Target soul '${targetSoulId}' not found` },
+        { status: 404 }
+      );
+    }
+
+    // Load source event from source soul's events.jsonl
+    const sourceEventsPath = path.join(
+      SOULS_DIR,
+      sourceSoulId,
+      "evolution",
+      "events.jsonl"
+    );
+
+    interface EvolutionEventEntry {
+      eventId: string;
+      soulId: string;
+      category: string;
+      trigger: string;
+      summary: string;
+      proposedChange: {
+        target: string;
+        action: string;
+        content?: Record<string, unknown>;
+      };
+      reviewStatus: string;
+      scope?: { transferRule?: string };
+    }
+
+    let sourceEvent: EvolutionEventEntry | null = null;
+    try {
+      const content = await fs.readFile(sourceEventsPath, "utf-8");
+      const lines = content.trim().split("\n").filter(Boolean);
+      const events: EvolutionEventEntry[] = lines.map((line) => JSON.parse(line));
+      sourceEvent = events.find((e) => e.eventId === sourceEventId) ?? null;
+    } catch {
+      return NextResponse.json(
+        { error: "Source events file not found" },
+        { status: 404 }
+      );
+    }
+
+    if (!sourceEvent) {
+      return NextResponse.json(
+        { error: `Source event '${sourceEventId}' not found` },
+        { status: 404 }
+      );
+    }
+
+    // Check gene's transferRule if scope exists
+    const geneContent = sourceEvent.proposedChange?.content as Record<string, unknown> | undefined;
+    const geneScope = geneContent?.scope as Record<string, unknown> | undefined;
+    if (geneScope?.transferRule === "never") {
+      return NextResponse.json(
+        { error: "This gene is marked as non-transferable (transferRule: never)" },
+        { status: 403 }
+      );
+    }
+
+    // Create propagation event for target soul
+    const propagationEventId = `${sourceEventId}-propagate-${targetSoulId}`;
+    const propagationEvent = {
+      eventId: propagationEventId,
+      soulId: targetSoulId,
+      category: sourceEvent.category,
+      trigger: "cross_soul_propagation",
+      summary: `Inherited: ${sourceEvent.summary}`,
+      proposedChange: {
+        ...sourceEvent.proposedChange,
+        metadata: {
+          sourceSoul: sourceSoulId,
+          sourceEvent: sourceEventId,
+        },
+      },
+      reviewStatus: "pending",
+    };
+
+    // Append to target soul's events.jsonl
+    const targetEventsPath = path.join(
+      SOULS_DIR,
+      targetSoulId,
+      "evolution",
+      "events.jsonl"
+    );
+    await fs.mkdir(path.dirname(targetEventsPath), { recursive: true });
+    await fs.appendFile(
+      targetEventsPath,
+      JSON.stringify(propagationEvent) + "\n"
+    );
+
+    // Log in DB with source tracking
+    const db = getDb();
+    await db.insert(soulEvolutionLog).values({
+      soulId: targetSoulId,
+      eventId: propagationEventId,
+      eventType: sourceEvent.category,
+      description: `Inherited: ${sourceEvent.summary}`,
+      reviewStatus: "pending",
+      sourceSoulId: sourceSoulId,
+      sourceEventId: sourceEventId,
+    });
+
+    return NextResponse.json({
+      success: true,
+      propagationEventId,
+      sourceSoulId,
+      targetSoulId,
+    });
+  } catch (error) {
+    console.error("Failed to propagate gene:", error);
+    return NextResponse.json(
+      { error: "Failed to propagate gene" },
+      { status: 500 }
+    );
+  }
+}

package/mission-control/src/app/api/souls/route.ts

@@ -0,0 +1,174 @@
+import { NextRequest, NextResponse } from "next/server";
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+
+const SOULS_DIR = path.join(os.homedir(), ".openclaw/souls");
+const REGISTRY_PATH = path.join(SOULS_DIR, "registry.json");
+
+interface Soul {
+  id: string;
+  type: string;
+  basePath: string;
+  capabilities: {
+    skills: string[];
+    tools: string[];
+    mcpServers: string[];
+  };
+  specializations: string[];
+  evolutionEnabled: boolean;
+  parentSoul: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+interface SoulRegistry {
+  version: string;
+  souls: Soul[];
+}
+
+async function loadRegistry(): Promise<SoulRegistry> {
+  try {
+    const content = await fs.readFile(REGISTRY_PATH, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    // If registry doesn't exist, return empty registry
+    return { version: "1.0.0", souls: [] };
+  }
+}
+
+async function saveRegistry(registry: SoulRegistry): Promise<void> {
+  await fs.mkdir(SOULS_DIR, { recursive: true });
+  await fs.writeFile(REGISTRY_PATH, JSON.stringify(registry, null, 2));
+}
+
+// GET /api/souls - List all souls
+// GET /api/souls?id=soul-id - Get specific soul
+export async function GET(request: NextRequest) {
+  try {
+    const registry = await loadRegistry();
+    const { searchParams } = new URL(request.url);
+    const soulId = searchParams.get("id");
+
+    if (soulId) {
+      const soul = registry.souls.find((s) => s.id === soulId);
+      if (!soul) {
+        return NextResponse.json({ error: "Soul not found" }, { status: 404 });
+      }
+      return NextResponse.json(soul);
+    }
+
+    return NextResponse.json(registry.souls);
+  } catch (error) {
+    console.error("Failed to load souls:", error);
+    return NextResponse.json(
+      { error: "Failed to load souls" },
+      { status: 500 }
+    );
+  }
+}
+
+// POST /api/souls - Register new soul
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const registry = await loadRegistry();
+
+    // Check if soul already exists
+    if (registry.souls.find((s) => s.id === body.id)) {
+      return NextResponse.json(
+        { error: "Soul already exists" },
+        { status: 409 }
+      );
+    }
+
+    const newSoul: Soul = {
+      ...body,
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    };
+
+    registry.souls.push(newSoul);
+    await saveRegistry(registry);
+
+    return NextResponse.json(newSoul, { status: 201 });
+  } catch (error) {
+    console.error("Failed to register soul:", error);
+    return NextResponse.json(
+      { error: "Failed to register soul" },
+      { status: 500 }
+    );
+  }
+}
+
+// PATCH /api/souls?id=soul-id - Update soul
+export async function PATCH(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const soulId = searchParams.get("id");
+
+    if (!soulId) {
+      return NextResponse.json(
+        { error: "Soul ID required" },
+        { status: 400 }
+      );
+    }
+
+    const body = await request.json();
+    const registry = await loadRegistry();
+    const soulIndex = registry.souls.findIndex((s) => s.id === soulId);
+
+    if (soulIndex === -1) {
+      return NextResponse.json({ error: "Soul not found" }, { status: 404 });
+    }
+
+    registry.souls[soulIndex] = {
+      ...registry.souls[soulIndex],
+      ...body,
+      updatedAt: new Date().toISOString(),
+    };
+
+    await saveRegistry(registry);
+
+    return NextResponse.json(registry.souls[soulIndex]);
+  } catch (error) {
+    console.error("Failed to update soul:", error);
+    return NextResponse.json(
+      { error: "Failed to update soul" },
+      { status: 500 }
+    );
+  }
+}
+
+// DELETE /api/souls?id=soul-id - Delete soul
+export async function DELETE(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const soulId = searchParams.get("id");
+
+    if (!soulId) {
+      return NextResponse.json(
+        { error: "Soul ID required" },
+        { status: 400 }
+      );
+    }
+
+    const registry = await loadRegistry();
+    const filtered = registry.souls.filter((s) => s.id !== soulId);
+
+    if (filtered.length === registry.souls.length) {
+      return NextResponse.json({ error: "Soul not found" }, { status: 404 });
+    }
+
+    registry.souls = filtered;
+    await saveRegistry(registry);
+
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    console.error("Failed to delete soul:", error);
+    return NextResponse.json(
+      { error: "Failed to delete soul" },
+      { status: 500 }
+    );
+  }
+}

package/mission-control/src/app/api/tasks/[id]/handoff/route.ts

@@ -0,0 +1,115 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getDb } from "@/lib/db";
+import { tasks, soulHandoffs } from "@/lib/db/schema";
+import { eq } from "drizzle-orm";
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+
+const HANDOFFS_DIR = path.join(
+  os.homedir(),
+  ".openclaw/workspace/memory-vault/handoffs"
+);
+
+interface HandoffRequest {
+  toSoul: string;
+  reason: string;
+  context?: {
+    files?: string[];
+    focusAreas?: string[];
+    previousWork?: string[];
+  };
+}
+
+// POST /api/tasks/:id/handoff - Hand off task to another soul
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  try {
+    const { id: taskId } = await params;
+    const body: HandoffRequest = await request.json();
+
+    const db = getDb();
+
+    // Get current task
+    const [task] = await db.select().from(tasks).where(eq(tasks.id, taskId));
+
+    if (!task) {
+      return NextResponse.json({ error: "Task not found" }, { status: 404 });
+    }
+
+    const fromSoul = task.soulId || "daedalus";
+
+    // Create handoff document in ClawVault
+    await fs.mkdir(HANDOFFS_DIR, { recursive: true });
+    const handoffDocPath = path.join(HANDOFFS_DIR, `${taskId}-handoff.md`);
+
+    const handoffDoc = `# Task Handoff: ${taskId}
+From: ${fromSoul} → ${body.toSoul}
+Reason: ${body.reason}
+Date: ${new Date().toISOString()}
+
+## Task Context
+**Title:** ${task.title}
+**Status:** ${task.status}
+**Owner:** ${task.owner}
+
+## Success Criteria
+${
+  task.successCriteria
+    ? JSON.parse(task.successCriteria)
+        .map((c: string) => `- ${c}`)
+        .join("\n")
+    : "- Complete the task successfully"
+}
+
+## Previous Work
+${body.context?.previousWork?.map((w) => `- ${w}`).join("\n") || "- Initial handoff"}
+
+## Focus Areas
+${body.context?.focusAreas?.map((a) => `- ${a}`).join("\n") || "- Follow task description"}
+
+## Resources
+${body.context?.files?.map((f) => `- ${f}`).join("\n") || "- See task artifacts"}
+
+## Next Steps
+${task.nextAction || "Begin work on this task"}
+`;
+
+    await fs.writeFile(handoffDocPath, handoffDoc);
+
+    // Update task with new soul
+    await db
+      .update(tasks)
+      .set({
+        soulId: body.toSoul,
+        handoffSource: fromSoul,
+        handoffReason: body.reason,
+        updatedAt: new Date().toISOString(),
+      })
+      .where(eq(tasks.id, taskId));
+
+    // Log handoff in soulHandoffs table
+    await db.insert(soulHandoffs).values({
+      taskId,
+      fromSoul,
+      toSoul: body.toSoul,
+      reason: body.reason,
+      contextPath: handoffDocPath,
+    });
+
+    return NextResponse.json({
+      success: true,
+      handoffDocPath,
+      fromSoul,
+      toSoul: body.toSoul,
+    });
+  } catch (error) {
+    console.error("Failed to hand off task:", error);
+    return NextResponse.json(
+      { error: "Failed to hand off task" },
+      { status: 500 }
+    );
+  }
+}