@mndrk/agx 2.0.18 → 2.0.20

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/lib/participants-store.ts

@@ -130,8 +130,8 @@ function migrateLegacyParticipantIds(db: Database.Database): void {
     const updateMessages = tableNames.has("messages")
       ? db.prepare("UPDATE messages SET participant_id = ? WHERE participant_id = ?")
       : null;
-    const updateLogs = tableNames.has("logs")
-      ? db.prepare("UPDATE logs SET participant_id = ? WHERE participant_id = ?")
+    const updateAgentProcesses = tableNames.has("agent_processes")
+      ? db.prepare("UPDATE agent_processes SET agent_id = ? WHERE agent_id = ?")
       : null;
     const updateReactions = tableNames.has("message_reactions")
       ? db.prepare("UPDATE message_reactions SET participant_id = ? WHERE participant_id = ?")
@@ -143,7 +143,7 @@ function migrateLegacyParticipantIds(db: Database.Database): void {
 
     for (const op of referenceOps) {
       updateMessages?.run(op.to, op.from);
-      updateLogs?.run(op.to, op.from);
+      updateAgentProcesses?.run(op.to, op.from);
       updateReactions?.run(op.to, op.from);
     }
   });

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/lib/sqlite-query-adapter.ts

@@ -58,14 +58,10 @@ export function getSQLiteDb(): Database.Database {
     throw new Error(`SQLite startup validation failed:\n${msgs.join("\n")}`);
   }
 
-  // Run DDL if this is a fresh database
-  if (isNew) {
-    initSQLiteSchema(_db);
-  } else {
-    // Runtime migrations must run BEFORE DDL re-apply (DDL may reference new columns)
+  // Ensure all tables exist (idempotent DDL), then run migrations
+  initSQLiteSchema(_db);
+  if (!isNew) {
     runMigrations(_db);
-    // Ensure tables exist even on existing DBs (idempotent DDL)
-    initSQLiteSchema(_db);
   }
 
   return _db;
@@ -84,27 +80,52 @@ function initSQLiteSchema(db: Database.Database): void {
 // ── Runtime migrations (idempotent) ──────────────────────────────────────────
 
 function runMigrations(db: Database.Database): void {
-  // Add is_default column to teams table
-  const cols = db.pragma("table_info(teams)") as { name: string }[];
-  if (!cols.some((c) => c.name === "is_default")) {
-    db.exec("ALTER TABLE teams ADD COLUMN is_default INTEGER NOT NULL DEFAULT 0");
-    db.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_teams_default ON teams (user_id) WHERE is_default = 1");
-  }
-
-  // Agent process registry table
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS agent_processes (
-      thread_id   TEXT NOT NULL,
-      agent_id    TEXT NOT NULL,
-      pid         INTEGER NOT NULL DEFAULT 0,
-      state       TEXT NOT NULL DEFAULT 'spawning',
-      since_message_id TEXT NOT NULL DEFAULT '',
-      started_at  INTEGER NOT NULL,
-      last_activity INTEGER NOT NULL,
-      PRIMARY KEY (thread_id, agent_id)
-    )
-  `);
-  db.exec("CREATE INDEX IF NOT EXISTS idx_agent_processes_state ON agent_processes (state)");
+  // Add is_default column to teams table (skip if teams table doesn't exist)
+  const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='teams'").all();
+  if (tables.length > 0) {
+    const cols = db.pragma("table_info(teams)") as { name: string }[];
+    if (!cols.some((c) => c.name === "is_default")) {
+      db.exec("ALTER TABLE teams ADD COLUMN is_default INTEGER NOT NULL DEFAULT 0");
+      db.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_teams_default ON teams (user_id) WHERE is_default = 1");
+    }
+  }
+
+  const graphTables = db
+    .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='execution_graphs'")
+    .all();
+  if (graphTables.length > 0) {
+    const columns = db.pragma("table_info(execution_graphs)") as { name: string }[];
+    if (!columns.some((column) => column.name === "schedule")) {
+      db.exec("ALTER TABLE execution_graphs ADD COLUMN schedule JSON");
+    }
+  }
+
+  // Recreate graph_nodes to add 'function' to the type CHECK constraint
+  const gnTables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='graph_nodes'").all();
+  if (gnTables.length > 0) {
+    const sql = (db.prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name='graph_nodes'").get() as { sql: string } | undefined)?.sql ?? "";
+    if (sql.includes("'root')") && !sql.includes("'function'")) {
+      db.exec(`
+        CREATE TABLE graph_nodes_new (
+          graph_id TEXT NOT NULL REFERENCES execution_graphs(id) ON DELETE CASCADE,
+          node_id TEXT NOT NULL,
+          type TEXT NOT NULL,
+          status TEXT NOT NULL,
+          config JSON NOT NULL DEFAULT '{}',
+          output JSON,
+          metrics JSON,
+          PRIMARY KEY (graph_id, node_id),
+          CHECK (type IN ('work', 'gate', 'fork', 'join', 'conditional', 'root', 'function')),
+          CHECK (status IN ('pending', 'running', 'awaiting_human', 'done', 'passed', 'failed', 'blocked', 'skipped', 'stopped'))
+        );
+        INSERT INTO graph_nodes_new SELECT * FROM graph_nodes;
+        DROP TABLE graph_nodes;
+        ALTER TABLE graph_nodes_new RENAME TO graph_nodes;
+        CREATE INDEX IF NOT EXISTS idx_graph_nodes_graph_id ON graph_nodes (graph_id);
+      `);
+    }
+  }
+
 }
 
 // ── JSON column set (same as db-adapter.ts) ─────────────────────────────────

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/lib/storage/thread-adapter.ts

@@ -3,7 +3,7 @@ import type { GroupMessage } from "../types";
 /**
  * Lifecycle status for a conversation thread.
  */
-export type ThreadStatus = "thinking" | "converged" | "resolved" | "parked" | "archived";
+export type ThreadStatus = "thinking" | "converged" | "resolved" | "in-review" | "archived" | "paused";
 
 /**
  * Arbitrary metadata that can be stored alongside a thread for sorting/filtering.

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/lib/stream-multiplexer.ts

@@ -1,7 +1,7 @@
 import { readFile } from "fs/promises";
 import type { Participant, ChatEvent } from "./types";
 import { runCliResponse } from "./cli-runner";
-import { register, update as updateProcess, remove as removeProcess } from "./agent-process-registry";
+import { register, update as updateProcess } from "./agent-process-registry";
 import { saveMessages, setReaction, saveLogs } from "./history-store";
 import { parseReactionSignals } from "./reaction-protocol";
 import { getAttachmentMeta } from "./attachment-store";
@@ -255,6 +255,28 @@ const SKIP_SIGNAL = "[SKIP]";
 const DEFAULT_MAX_ROUNDS = 10;
 const SIMILARITY_THRESHOLD = 0.5;
 
+export interface StreamProjectReference {
+  id: string;
+  slug: string;
+  name: string;
+}
+
+export interface StreamProjectDetail extends StreamProjectReference {
+  description?: string | null;
+  ciCdInfo?: string | null;
+  workflowId?: string | null;
+  repos: Array<{
+    name: string;
+    path?: string | null;
+    notes?: string | null;
+  }>;
+}
+
+export interface StreamProjectContext {
+  activeProject?: StreamProjectReference | null;
+  mentionedProjects?: StreamProjectDetail[];
+}
+
 /** Simple word-overlap similarity (Jaccard index) to detect repetitive responses */
 function similarity(a: string, b: string): number {
   const wordsA = new Set(a.toLowerCase().replace(/[^\w\s]/g, "").split(/\s+/).filter(Boolean));
@@ -346,7 +368,8 @@ function buildContext(
   transcript: Array<{ name: string; content: string }>,
   recentHistory: Array<{ id: string; name: string; content: string }>,
   exchangeMessages: Array<{ id: string; name: string; content: string }>,
-  currentUserMessageId: string | null
+  currentUserMessageId: string | null,
+  projectContext?: StreamProjectContext
 ): string {
   const otherActive = active.filter((p) => p.id !== self.id);
   const otherNames = otherActive.map((p) => p.name).join(", ");
@@ -434,11 +457,46 @@ Do NOT repeat, rephrase, or summarize your own previous messages. If you have no
     }
   }
 
+  const activeProject = projectContext?.activeProject;
+  const mentionedProjects = projectContext?.mentionedProjects ?? [];
+  if (activeProject || mentionedProjects.length > 0) {
+    context += `\n\n<project-context>`;
+    if (activeProject) {
+      context += `\nActive project scope: ${activeProject.name} (${activeProject.slug}, id: ${activeProject.id}).`;
+    }
+    if (mentionedProjects.length > 0) {
+      const blocks = mentionedProjects.map((project) => {
+        const repos = project.repos.length > 0
+          ? project.repos
+              .map((repo) => {
+                const parts = [repo.name];
+                if (repo.path) parts.push(`path: ${repo.path}`);
+                if (repo.notes) parts.push(`notes: ${repo.notes}`);
+                return `- ${parts.join(" | ")}`;
+              })
+              .join("\n")
+          : "- (none)";
+        const details = [
+          `Project: ${project.name} (${project.slug}, id: ${project.id})`,
+          project.description ? `Description: ${project.description}` : null,
+          project.ciCdInfo ? `CI/CD: ${project.ciCdInfo}` : null,
+          project.workflowId ? `Workflow ID: ${project.workflowId}` : null,
+          `Repos:\n${repos}`,
+        ]
+          .filter(Boolean)
+          .join("\n");
+        return details;
+      });
+      context += `\nMentioned project details (included only because the user explicitly mentioned them):\n${blocks.join("\n\n")}`;
+    }
+    context += `\n</project-context>`;
+  }
+
   return context;
 }
 
 async function runAgent(
-  threadId: string,
+  workspaceId: string,
   p: Participant,
   all: Participant[],
   active: Participant[],
@@ -447,9 +505,11 @@ async function runAgent(
   recentHistory: Array<{ id: string; name: string; content: string }>,
   exchangeMessages: Array<{ id: string; name: string; content: string }>,
   currentUserMessageId: string | null,
+  projectContext: StreamProjectContext | undefined,
   signal: AbortSignal | undefined,
   write: (event: ChatEvent) => void,
-  rootMessageId?: string | null
+  rootMessageId?: string | null,
+  onRegister?: (agentProcessId: number) => void
 ): Promise<{
   skipped: boolean;
   response: string;
@@ -457,6 +517,7 @@ async function runAgent(
   parallel: boolean;
   parallelIds: Set<string>;
   messageId?: string;
+  agentProcessId: number;
 }> {
   let fullResponse = "";
 
@@ -516,7 +577,8 @@ async function runAgent(
     transcript,
     recentHistory,
     exchangeMessages,
-    currentUserMessageId
+    currentUserMessageId,
+    projectContext
   );
   write({
     type: "log",
@@ -534,16 +596,22 @@ async function runAgent(
   });
 
   const sinceMessageId = currentUserMessageId || "";
-  register({
-    threadId,
+  const responseMessageId = `${p.id}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const agentProcessId = register({
+    workspaceId,
+    threadId: rootMessageId || "",
     agentId: p.id,
     pid: 0,
     state: "spawning",
     sinceMessageId,
+    responseMessageId,
     startedAt: Date.now(),
     lastActivity: Date.now(),
+    projectSlug: projectContext?.activeProject?.slug || "",
   });
+  onRegister?.(agentProcessId);
 
+  let spawnedPid: number | null = null;
   try {
     await runCliResponse({
       provider: p.provider,
@@ -555,28 +623,29 @@ async function runAgent(
       systemContext,
       signal,
       onSpawn: (pid) => {
-        updateProcess(threadId, p.id, { pid, state: "running", lastActivity: Date.now() });
+        spawnedPid = pid;
+        updateProcess(workspaceId, p.id, { pid, state: "running", lastActivity: Date.now() });
       },
       onLog: (stream, line) => {
         write({ type: "log", participantId: p.id, stream, line });
       },
       onDelta: (delta) => {
         fullResponse += delta;
-        updateProcess(threadId, p.id, { lastActivity: Date.now() });
+        updateProcess(workspaceId, p.id, { lastActivity: Date.now() });
       },
     });
-    updateProcess(threadId, p.id, { state: "done", lastActivity: Date.now() });
+    updateProcess(workspaceId, p.id, { state: "done", lastActivity: Date.now() });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     const isAbort = signal?.aborted;
-    updateProcess(threadId, p.id, {
+    updateProcess(workspaceId, p.id, {
       state: isAbort ? "killed" : "error",
       lastActivity: Date.now(),
     });
-    logActivity(p.id, "error", { thread: rootMessageId || threadId, error: message });
+    logActivity(p.id, "error", { thread: rootMessageId || workspaceId, error: message });
     write({ type: "participant-error", participantId: p.id, error: message });
   } finally {
-    removeProcess(threadId, p.id);
+    // Keep the process row — logs reference it via agent_process_id
   }
 
   const parsed = parseReactionSignals(fullResponse);
@@ -592,12 +661,14 @@ async function runAgent(
   for (const signalData of parsed.signals) {
     try {
       const result = await setReaction({
-        threadId,
+        threadId: workspaceId,
         messageId: signalData.target,
         participantId: p.id,
         type: signalData.type,
         reason: signalData.reason,
         blockerCode: signalData.blockerCode,
+        hostPid: spawnedPid,
+        responseMessageId,
       });
       write({
         type: "message-reactions",
@@ -618,7 +689,7 @@ async function runAgent(
   const trimmed = parsed.cleanedText.trim();
 
   if (trimmed === SKIP_SIGNAL) {
-    logActivity(p.id, "skip", { thread: rootMessageId || threadId });
+    logActivity(p.id, "skip", { thread: rootMessageId || workspaceId });
     write({ type: "participant-end", participantId: p.id });
     return {
       skipped: true,
@@ -626,17 +697,17 @@ async function runAgent(
       mentions: new Set(),
       parallel: false,
       parallelIds: new Set(),
+      agentProcessId,
     };
   }
 
   const cleanResponse = cleanParallelMentions(trimmed, all);
   let messageId: string | undefined;
   if (cleanResponse) {
-    const generatedId = `${p.id}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     try {
-      await saveMessages(threadId, [
+      await saveMessages(workspaceId, [
         {
-          id: generatedId,
+          id: responseMessageId,
           role: "assistant",
           participantId: p.id,
           content: cleanResponse,
@@ -646,7 +717,7 @@ async function runAgent(
           depth: rootMessageId ? 1 : 0,
         },
       ]);
-      messageId = generatedId;
+      messageId = responseMessageId;
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       write({
@@ -665,7 +736,7 @@ async function runAgent(
       const journalEntry = appendJournal(p.id, {
         t: new Date().toISOString(),
         type: "post",
-        thread: rootMessageId || threadId,
+        thread: rootMessageId || workspaceId,
         observation: `Responded to thread`,
         judgement: insights.judgement,
         delta: insights.delta,
@@ -702,7 +773,7 @@ async function runAgent(
   if (cleanResponse) {
     const reactionTypes = parsed.signals.map((s) => s.type);
     logActivity(p.id, "message", {
-      thread: rootMessageId || threadId,
+      thread: rootMessageId || workspaceId,
       messageId,
       response: cleanResponse,
       prompt,
@@ -720,6 +791,7 @@ async function runAgent(
       mentions: new Set(),
       parallel: false,
       parallelIds: new Set(),
+      agentProcessId,
     };
   }
 
@@ -731,15 +803,17 @@ async function runAgent(
     parallel: hasParallel,
     parallelIds,
     messageId,
+    agentProcessId,
   };
 }
 
 export function createMultiplexedStream({
-  threadId,
+  threadId: workspaceId,
   allParticipants,
   mentioned,
   initialParallelIds,
   prompt,
+  projectContext,
   signal,
   maxRounds,
   recentHistory,
@@ -751,6 +825,7 @@ export function createMultiplexedStream({
   mentioned: Set<string>;
   initialParallelIds?: Set<string>;
   prompt: string;
+  projectContext?: StreamProjectContext;
   signal?: AbortSignal;
   maxRounds?: number;
   recentHistory?: Array<{ id: string; name: string; content: string }>;
@@ -761,7 +836,9 @@ export function createMultiplexedStream({
 
   return new ReadableStream({
     async start(controller) {
-      const logBuffer: Array<{ participantId: string; stream: "stdout" | "stderr"; line: string; timestamp: number }> = [];
+      const logBuffer: Array<{ agentProcessId: number; stream: "stdout" | "stderr"; line: string; timestamp: number }> = [];
+
+      const agentProcessIds = new Map<string, number>();
 
       const write = (event: ChatEvent) => {
         try {
@@ -770,19 +847,35 @@ export function createMultiplexedStream({
           // stream closed
         }
         if (event.type === "log") {
-          logBuffer.push({
-            participantId: event.participantId,
-            stream: event.stream,
-            line: event.line,
-            timestamp: Date.now(),
-          });
+          const processId = agentProcessIds.get(event.participantId);
+          if (processId) {
+            logBuffer.push({
+              agentProcessId: processId,
+              stream: event.stream,
+              line: event.line,
+              timestamp: Date.now(),
+            });
+          }
         }
       };
 
       const flushLogs = async () => {
-        if (logBuffer.length > 0) {
-          await saveLogs(threadId, logBuffer).catch(() => {});
+        if (logBuffer.length === 0) return;
+        // Group by agentProcessId and flush each batch
+        const byProcess = new Map<number, Array<{ stream: "stdout" | "stderr"; line: string; timestamp: number }>>();
+        for (const entry of logBuffer) {
+          let batch = byProcess.get(entry.agentProcessId);
+          if (!batch) {
+            batch = [];
+            byProcess.set(entry.agentProcessId, batch);
+          }
+          batch.push({ stream: entry.stream, line: entry.line, timestamp: entry.timestamp });
         }
+        await Promise.all(
+          Array.from(byProcess.entries()).map(([processId, entries]) =>
+            saveLogs(processId, entries).catch(() => {})
+          )
+        );
       };
 
       const transcript: Array<{ name: string; content: string }> = [];
@@ -830,7 +923,7 @@ export function createMultiplexedStream({
 
             const tasks = initialParallelAgents.map(async (agent) => {
               const result = await runAgent(
-                threadId,
+                workspaceId,
                 agent,
                 allParticipants,
                 activeList,
@@ -839,9 +932,11 @@ export function createMultiplexedStream({
                 recentHistory || [],
                 exchangeMessages,
                 currentUserMessageId || null,
+                projectContext,
                 signal,
                 write,
-                rootMessageId
+                rootMessageId,
+                (id) => agentProcessIds.set(agent.id, id)
               );
               return { agent, result };
             });
@@ -893,19 +988,21 @@ export function createMultiplexedStream({
           if (alreadyRanThisRound.has(p.id)) continue;
 
           const result = await runAgent(
-            threadId,
+            workspaceId,
             p,
             allParticipants,
             activeList,
             prompt,
-            transcript,
-            recentHistory || [],
-            exchangeMessages,
-            currentUserMessageId || null,
-            signal,
-            write,
-            rootMessageId
-          );
+              transcript,
+              recentHistory || [],
+              exchangeMessages,
+              currentUserMessageId || null,
+              projectContext,
+              signal,
+              write,
+              rootMessageId,
+              (id) => agentProcessIds.set(p.id, id)
+            );
 
           if (result.skipped) continue;
 
@@ -962,7 +1059,7 @@ export function createMultiplexedStream({
 
             const tasks = parallelAgents.map(async (a) => {
               const r = await runAgent(
-                threadId,
+                workspaceId,
                 a,
                 allParticipants,
                 updatedActiveList,
@@ -971,9 +1068,11 @@ export function createMultiplexedStream({
                 recentHistory || [],
                 exchangeMessages,
                 currentUserMessageId || null,
+                projectContext,
                 signal,
                 write,
-                rootMessageId
+                rootMessageId,
+                (id) => agentProcessIds.set(a.id, id)
               );
               return { agent: a, result: r };
             });

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/lib/tiptap/composer-mentions.ts

@@ -44,6 +44,42 @@ export const ParticipantMention = Node.create({
   },
 });
 
+/**
+ * Project mention pill — renders @ProjectName.
+ */
+export const ProjectMention = Node.create({
+  name: "projectMention",
+  group: "inline",
+  inline: true,
+  atom: true,
+
+  addAttributes() {
+    return {
+      id: { default: null },
+      slug: { default: "" },
+      name: { default: "" },
+    };
+  },
+
+  parseHTML() {
+    return [{ tag: 'span[data-project-mention]' }];
+  },
+
+  renderHTML({ node, HTMLAttributes }) {
+    return [
+      "span",
+      mergeAttributes(HTMLAttributes, {
+        "data-project-mention": "",
+        "data-id": node.attrs.id,
+        "data-slug": node.attrs.slug,
+        class: "composer-pill composer-pill--project",
+        contenteditable: "false",
+      }),
+      `@${node.attrs.name}`,
+    ];
+  },
+});
+
 /**
  * File mention pill — renders @/path or @~/path.
  */
@@ -102,10 +138,6 @@ export const ThreadMention = Node.create({
   },
 
   renderHTML({ node, HTMLAttributes }) {
-    const shortTitle =
-      node.attrs.title.length > 40
-        ? node.attrs.title.slice(0, 37) + "..."
-        : node.attrs.title;
     return [
       "span",
       mergeAttributes(HTMLAttributes, {
@@ -114,7 +146,7 @@ export const ThreadMention = Node.create({
         class: "composer-pill composer-pill--thread",
         contenteditable: "false",
       }),
-      `#${shortTitle}`,
+      `#${node.attrs.title}`,
     ];
   },
 });

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/lib/tiptap/serialize-composer.ts

@@ -4,6 +4,7 @@ import type { JSONContent } from "@tiptap/core";
  * Serialize a Tiptap document JSON back to plain text with mention tokens.
  *
  * - participantMention → @Name or @@Name
+ * - projectMention → @~project:slug
  * - fileMention → @/path or @~/path
  * - threadMention → @#shortId
  * - text nodes → verbatim text
@@ -44,6 +45,17 @@ function serializeParagraph(node: JSONContent): string {
         break;
       }
 
+      case "projectMention": {
+        const attrs = child.attrs ?? {};
+        const slug = String(attrs.slug ?? "").trim();
+        if (slug) {
+          text += `@~project:${slug}`;
+        } else if (attrs.name) {
+          text += `@${attrs.name}`;
+        }
+        break;
+      }
+
       case "fileMention": {
         const attrs = child.attrs ?? {};
         const display = attrs.relativePath || attrs.path;

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/migrations/sqlite_schema.sql

@@ -322,13 +322,15 @@ CREATE TABLE IF NOT EXISTS execution_graphs (
     mode TEXT NOT NULL,
     policy JSON NOT NULL DEFAULT '{}',
     done_criteria JSON NOT NULL DEFAULT '{}',
+    schedule JSON,
     execution_state TEXT NOT NULL DEFAULT 'ready',
     created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
     updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
     CHECK (mode IN ('SIMPLE', 'PROJECT')),
     CHECK (execution_state IN ('ready', 'running', 'paused', 'stopped', 'done')),
     CHECK (json_valid(policy)),
-    CHECK (json_valid(done_criteria))
+    CHECK (json_valid(done_criteria)),
+    CHECK (schedule IS NULL OR json_valid(schedule))
 );
 
 CREATE TABLE IF NOT EXISTS graph_nodes (
@@ -340,7 +342,7 @@ CREATE TABLE IF NOT EXISTS graph_nodes (
     output JSON,
     metrics JSON,
     PRIMARY KEY (graph_id, node_id),
-    CHECK (type IN ('work', 'gate', 'fork', 'join', 'conditional', 'root')),
+    CHECK (type IN ('work', 'gate', 'fork', 'join', 'conditional', 'root', 'function')),
     CHECK (status IN ('pending', 'running', 'awaiting_human', 'done', 'passed', 'failed', 'blocked', 'skipped', 'stopped')),
     CHECK (json_valid(config)),
     CHECK (output IS NULL OR json_valid(output)),