workplane 0.3.1 → 0.4.1

package/dist/server.js

@@ -128,20 +128,23 @@ import { z } from "zod";
 
 // ../core/src/env.ts
 import { config as dotenvConfig } from "dotenv";
+import { homedir } from "os";
+import { join } from "path";
 var envLoaded = false;
 function loadLocalEnv() {
   if (envLoaded) {
     return;
   }
+  dotenvConfig({ path: ".env.local" });
+  dotenvConfig({ path: join(homedir(), ".workplane", ".env") });
   dotenvConfig({ path: ".env" });
-  dotenvConfig({ path: ".env.local", override: true });
   envLoaded = true;
 }
 
 // ../core/src/config.ts
 loadLocalEnv();
 var serverEnvSchema = z.object({
-  DATABASE_URL: z.string().min(1),
+  DATABASE_URL: z.string().optional().default("sqlite://~/.workplane/workplane.db"),
   WORKPLANE_SERVER_PORT: z.string().optional().default("8787").transform((value) => Number.parseInt(value, 10)),
   WORKPLANE_NODE_TOKEN: z.string().optional(),
   WORKPLANE_OPERATOR_TOKEN: z.string().optional(),
@@ -171,17 +174,16 @@ function parseCsv(value) {
 }
 
 // ../db/src/client.ts
+import { mkdirSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname, join as join2 } from "path";
+import { drizzle as drizzlePg } from "drizzle-orm/node-postgres";
+import { drizzle as drizzleSqlite } from "drizzle-orm/better-sqlite3";
+import Database from "better-sqlite3";
 import { Pool } from "pg";
-var pools = /* @__PURE__ */ new Map();
-function getPool(databaseUrl) {
-  const existing = pools.get(databaseUrl);
-  if (existing) {
-    return existing;
-  }
-  const pool = new Pool({ connectionString: databaseUrl });
-  pools.set(databaseUrl, pool);
-  return pool;
-}
+
+// ../db/src/pg-store.ts
+import { and, asc, desc, eq, gt, sql as sql2 } from "drizzle-orm";
 
 // ../core/src/ids.ts
 import { randomUUID } from "crypto";
@@ -189,8 +191,155 @@ function makeId(prefix) {
   return `${prefix}_${randomUUID().replace(/-/g, "").slice(0, 12)}`;
 }
 
-// ../server/src/store.ts
-function mapTask(row) {
+// ../db/src/schema/pg.ts
+var pg_exports = {};
+__export(pg_exports, {
+  artifacts: () => artifacts,
+  nodes: () => nodes,
+  runInputEvents: () => runInputEvents,
+  runLogs: () => runLogs,
+  runs: () => runs,
+  tasks: () => tasks
+});
+import { isNull, sql } from "drizzle-orm";
+import { bigint, bigserial, index, integer, jsonb, pgTable, text, timestamp, uniqueIndex } from "drizzle-orm/pg-core";
+var tasks = pgTable("tasks", {
+  id: text("id").primaryKey(),
+  kind: text("kind").notNull(),
+  adapter: text("adapter").notNull(),
+  payload: jsonb("payload").$type().notNull(),
+  requires: text("requires").array().notNull().default(sql`'{}'::text[]`),
+  status: text("status").notNull(),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => ({
+  statusCreatedAtIdx: index("idx_tasks_status_created_at").on(table.status, table.createdAt)
+}));
+var nodes = pgTable("nodes", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  capabilities: text("capabilities").array().notNull().default(sql`'{}'::text[]`),
+  status: text("status").notNull().default("online"),
+  lastHeartbeatAt: timestamp("last_heartbeat_at", { withTimezone: true }),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+});
+var runs = pgTable("runs", {
+  id: text("id").primaryKey(),
+  taskId: text("task_id").notNull().references(() => tasks.id),
+  nodeId: text("node_id").notNull().references(() => nodes.id),
+  attempt: integer("attempt").notNull(),
+  status: text("status").notNull(),
+  startedAt: timestamp("started_at", { withTimezone: true }),
+  endedAt: timestamp("ended_at", { withTimezone: true }),
+  error: text("error"),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => ({
+  taskIdIdx: index("idx_runs_task_id").on(table.taskId),
+  nodeIdIdx: index("idx_runs_node_id").on(table.nodeId)
+}));
+var runLogs = pgTable("run_logs", {
+  id: bigserial("id", { mode: "number" }).primaryKey(),
+  runId: text("run_id").notNull().references(() => runs.id),
+  stepName: text("step_name"),
+  stream: text("stream").notNull(),
+  message: text("message").notNull(),
+  timestamp: timestamp("timestamp", { withTimezone: true }).notNull().defaultNow()
+}, (table) => ({
+  runIdTimestampIdx: index("idx_run_logs_run_id_timestamp").on(table.runId, table.timestamp)
+}));
+var artifacts = pgTable("artifacts", {
+  id: text("id").primaryKey(),
+  runId: text("run_id").notNull().references(() => runs.id),
+  type: text("type").notNull(),
+  name: text("name").notNull(),
+  path: text("path").notNull(),
+  metadata: jsonb("metadata").$type(),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => ({
+  runIdIdx: index("idx_artifacts_run_id").on(table.runId)
+}));
+var runInputEvents = pgTable("run_input_events", {
+  id: bigserial("id", { mode: "number" }).primaryKey(),
+  runId: text("run_id").notNull().references(() => runs.id),
+  sequence: bigint("sequence", { mode: "number" }).notNull(),
+  kind: text("kind").notNull(),
+  payload: jsonb("payload").$type().notNull(),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  deliveredAt: timestamp("delivered_at", { withTimezone: true })
+}, (table) => ({
+  runSequenceUniqueIdx: uniqueIndex("idx_run_input_events_run_sequence").on(table.runId, table.sequence),
+  undeliveredIdx: index("idx_run_input_events_undelivered").on(table.runId, table.sequence).where(isNull(table.deliveredAt))
+}));
+
+// ../db/src/pg-store.ts
+function toTaskRecord(row) {
+  return {
+    id: row.id,
+    kind: row.kind,
+    adapter: row.adapter,
+    payload: row.payload,
+    requires: row.requires ?? [],
+    status: row.status,
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString()
+  };
+}
+function toRunRecord(row) {
+  return {
+    id: row.id,
+    taskId: row.taskId,
+    nodeId: row.nodeId,
+    attempt: row.attempt,
+    status: row.status,
+    startedAt: row.startedAt?.toISOString() ?? null,
+    endedAt: row.endedAt?.toISOString() ?? null,
+    error: row.error ?? null
+  };
+}
+function toNodeRecord(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    capabilities: row.capabilities ?? [],
+    status: row.status,
+    lastHeartbeatAt: row.lastHeartbeatAt?.toISOString() ?? null
+  };
+}
+function toLogRecord(row) {
+  return {
+    id: row.id,
+    runId: row.runId,
+    stepName: row.stepName ?? null,
+    stream: row.stream,
+    message: row.message,
+    timestamp: row.timestamp.toISOString()
+  };
+}
+function toArtifactRecord(row) {
+  return {
+    id: row.id,
+    runId: row.runId,
+    type: row.type,
+    name: row.name,
+    path: row.path,
+    metadata: row.metadata ?? null,
+    createdAt: row.createdAt.toISOString()
+  };
+}
+function toInputEventRecord(row) {
+  return {
+    id: row.id,
+    runId: row.runId,
+    sequence: row.sequence,
+    kind: row.kind,
+    payload: row.payload,
+    createdAt: row.createdAt.toISOString(),
+    deliveredAt: row.deliveredAt?.toISOString() ?? null
+  };
+}
+function mapRawTask(row) {
   return {
     id: String(row.id),
     kind: String(row.kind),
@@ -202,7 +351,7 @@ function mapTask(row) {
     updatedAt: new Date(String(row.updated_at)).toISOString()
   };
 }
-function mapRun(row) {
+function mapRawRun(row) {
   return {
     id: String(row.id),
     taskId: String(row.task_id),
@@ -214,385 +363,645 @@ function mapRun(row) {
     error: row.error ? String(row.error) : null
   };
 }
-function mapInputEvent(row) {
-  return {
-    id: Number(row.id),
-    runId: String(row.run_id),
-    sequence: Number(row.sequence),
-    kind: row.kind,
-    payload: row.payload ?? {},
-    createdAt: new Date(String(row.created_at)).toISOString(),
-    deliveredAt: row.delivered_at ? new Date(String(row.delivered_at)).toISOString() : null
-  };
-}
-function mapArtifact(row) {
-  return {
-    id: String(row.id),
-    runId: String(row.run_id),
-    type: String(row.type),
-    name: String(row.name),
-    path: String(row.path),
-    metadata: row.metadata ?? null,
-    createdAt: new Date(String(row.created_at)).toISOString()
-  };
-}
 var PgStore = class {
-  constructor(pool) {
-    this.pool = pool;
+  constructor(db) {
+    this.db = db;
   }
-  pool;
+  db;
   async createTask(input) {
     const taskId = makeId("task");
-    const result = await this.pool.query(
-      `
-      insert into tasks (id, kind, adapter, payload, requires, status)
-      values ($1, $2, $3, $4::jsonb, $5::text[], 'queued')
-      returning *
-      `,
-      [taskId, input.kind, input.adapter, JSON.stringify(input.payload), input.requires ?? []]
-    );
-    return mapTask(result.rows[0]);
+    const [row] = await this.db.insert(tasks).values({
+      id: taskId,
+      kind: input.kind,
+      adapter: input.adapter,
+      payload: input.payload,
+      requires: input.requires ?? [],
+      status: "queued"
+    }).returning();
+    return toTaskRecord(row);
   }
   async listTasks(status) {
-    const result = status ? await this.pool.query("select * from tasks where status = $1 order by created_at desc limit 100", [status]) : await this.pool.query("select * from tasks order by created_at desc limit 100");
-    return result.rows.map((row) => mapTask(row));
+    const rows = await this.db.select().from(tasks).where(status ? eq(tasks.status, status) : void 0).orderBy(desc(tasks.createdAt)).limit(100);
+    return rows.map(toTaskRecord);
   }
   async getTask(taskId) {
-    const result = await this.pool.query("select * from tasks where id = $1", [taskId]);
-    if (result.rowCount === 0) {
-      return null;
-    }
-    return mapTask(result.rows[0]);
+    const [row] = await this.db.select().from(tasks).where(eq(tasks.id, taskId));
+    return row ? toTaskRecord(row) : null;
   }
   async listRuns(filters) {
-    const taskId = filters?.taskId;
-    const status = filters?.status;
-    const result = taskId && status ? await this.pool.query("select * from runs where task_id = $1 and status = $2 order by created_at desc", [
-      taskId,
-      status
-    ]) : taskId ? await this.pool.query("select * from runs where task_id = $1 order by created_at desc", [taskId]) : status ? await this.pool.query("select * from runs where status = $1 order by created_at desc limit 100", [status]) : await this.pool.query("select * from runs order by created_at desc limit 100");
-    return result.rows.map((row) => mapRun(row));
+    const conditions = [];
+    if (filters?.taskId) conditions.push(eq(runs.taskId, filters.taskId));
+    if (filters?.status) conditions.push(eq(runs.status, filters.status));
+    const rows = await this.db.select().from(runs).where(conditions.length ? and(...conditions) : void 0).orderBy(desc(runs.createdAt)).limit(100);
+    return rows.map(toRunRecord);
   }
   async getRun(runId) {
-    const result = await this.pool.query("select * from runs where id = $1", [runId]);
-    if (result.rowCount === 0) {
-      return null;
-    }
-    return mapRun(result.rows[0]);
+    const [row] = await this.db.select().from(runs).where(eq(runs.id, runId));
+    return row ? toRunRecord(row) : null;
   }
   async registerNode(name, capabilities, preferredId) {
-    const existing = await this.pool.query("select * from nodes where name = $1", [name]);
-    if (existing.rowCount && existing.rowCount > 0) {
-      const row = existing.rows[0];
-      const nodeId2 = String(row.id);
-      const updated = await this.pool.query(
-        `
-        update nodes
-        set capabilities = $2::text[], status = 'online', last_heartbeat_at = now(), updated_at = now()
-        where id = $1
-        returning *
-        `,
-        [nodeId2, capabilities]
-      );
-      return this.mapNodeRecord(updated.rows[0]);
+    const [existing] = await this.db.select().from(nodes).where(eq(nodes.name, name));
+    if (existing) {
+      const [updated] = await this.db.update(nodes).set({ capabilities, status: "online", lastHeartbeatAt: sql2`now()`, updatedAt: sql2`now()` }).where(eq(nodes.id, existing.id)).returning();
+      return toNodeRecord(updated);
     }
     const nodeId = preferredId ?? makeId("node");
-    const result = await this.pool.query(
-      `
-      insert into nodes (id, name, capabilities, status, last_heartbeat_at)
-      values ($1, $2, $3::text[], 'online', now())
-      returning *
-      `,
-      [nodeId, name, capabilities]
-    );
-    return this.mapNodeRecord(result.rows[0]);
+    const [inserted] = await this.db.insert(nodes).values({
+      id: nodeId,
+      name,
+      capabilities,
+      status: "online",
+      lastHeartbeatAt: sql2`now()`
+    }).returning();
+    return toNodeRecord(inserted);
   }
   async getRunCancellationState(runId) {
-    const result = await this.pool.query(
-      `
-      select r.status as run_status, t.status as task_status
-      from runs r
-      join tasks t on t.id = r.task_id
-      where r.id = $1
-      `,
-      [runId]
-    );
-    if (result.rowCount === 0) {
-      return null;
-    }
-    const row = result.rows[0];
-    return {
-      runStatus: String(row.run_status),
-      taskStatus: String(row.task_status)
-    };
-  }
-  mapNodeRecord(row) {
-    return {
-      id: String(row.id),
-      name: String(row.name),
-      capabilities: row.capabilities ?? [],
-      status: row.status,
-      lastHeartbeatAt: row.last_heartbeat_at ? new Date(String(row.last_heartbeat_at)).toISOString() : null
-    };
+    const [row] = await this.db.select({ runStatus: runs.status, taskStatus: tasks.status }).from(runs).innerJoin(tasks, eq(tasks.id, runs.taskId)).where(eq(runs.id, runId));
+    return row ?? null;
   }
   async pollNode(nodeId, capabilities) {
-    const client = await this.pool.connect();
-    try {
-      await client.query("begin");
-      await this.touchNode(client, nodeId, capabilities);
-      const taskResult = await client.query(
-        `
-        select *
-        from tasks
-        where status = 'queued'
-          and requires <@ $1::text[]
-        order by created_at asc
-        limit 1
-        for update skip locked
-        `,
-        [capabilities]
-      );
-      if (taskResult.rowCount === 0) {
-        await client.query("commit");
-        return null;
-      }
+    return await this.db.transaction(async (tx) => {
+      await tx.execute(sql2`
+        UPDATE nodes
+        SET capabilities = ${capabilities}::text[], status = 'online',
+            last_heartbeat_at = now(), updated_at = now()
+        WHERE id = ${nodeId}
+      `);
+      const taskResult = await tx.execute(sql2`
+        SELECT * FROM tasks
+        WHERE status = 'queued' AND requires <@ ${capabilities}::text[]
+        ORDER BY created_at ASC
+        LIMIT 1
+        FOR UPDATE SKIP LOCKED
+      `);
+      if (taskResult.rows.length === 0) return null;
       const taskRow = taskResult.rows[0];
       const taskId = String(taskRow.id);
-      const runId = makeId("run");
-      const attemptResult = await client.query("select coalesce(max(attempt), 0) as max_attempt from runs where task_id = $1", [
-        taskId
-      ]);
+      const attemptResult = await tx.execute(sql2`
+        SELECT COALESCE(MAX(attempt), 0) AS max_attempt FROM runs WHERE task_id = ${taskId}
+      `);
       const attempt = Number(attemptResult.rows[0].max_attempt) + 1;
-      const runResult = await client.query(
-        `
-        insert into runs (id, task_id, node_id, attempt, status, started_at)
-        values ($1, $2, $3, $4, 'assigned', now())
-        returning *
-        `,
-        [runId, taskId, nodeId, attempt]
-      );
-      await client.query("update tasks set status = 'assigned', updated_at = now() where id = $1", [taskId]);
-      await client.query("commit");
+      const runId = makeId("run");
+      const runResult = await tx.execute(sql2`
+        INSERT INTO runs (id, task_id, node_id, attempt, status, started_at)
+        VALUES (${runId}, ${taskId}, ${nodeId}, ${attempt}, 'assigned', now())
+        RETURNING *
+      `);
+      await tx.execute(sql2`
+        UPDATE tasks SET status = 'assigned', updated_at = now() WHERE id = ${taskId}
+      `);
       return {
-        task: mapTask(taskRow),
-        run: mapRun(runResult.rows[0])
+        task: mapRawTask(taskRow),
+        run: mapRawRun(runResult.rows[0])
       };
-    } catch (error) {
-      await client.query("rollback");
-      throw error;
-    } finally {
-      client.release();
-    }
+    });
   }
   async updateRunStatus(runId, status, error) {
-    const client = await this.pool.connect();
-    try {
-      await client.query("begin");
-      const currentResult = await client.query(
-        `
-        select r.*, t.status as task_status
-        from runs r
-        join tasks t on t.id = r.task_id
-        where r.id = $1
-        for update
-        `,
-        [runId]
-      );
-      if (currentResult.rowCount === 0) {
-        await client.query("rollback");
-        return null;
-      }
+    return await this.db.transaction(async (tx) => {
+      const currentResult = await tx.execute(sql2`
+        SELECT r.*, t.status AS task_status
+        FROM runs r JOIN tasks t ON t.id = r.task_id
+        WHERE r.id = ${runId}
+        FOR UPDATE
+      `);
+      if (currentResult.rows.length === 0) return null;
       const currentRow = currentResult.rows[0];
       const currentTaskStatus = String(currentRow.task_status);
       if (currentTaskStatus === "cancelled" && status !== "cancelled") {
-        await client.query("commit");
-        return mapRun(currentRow);
-      }
-      const runResult = await client.query(
-        `
-        update runs
-        set status = $2, error = $3, ended_at = case when $2 in ('succeeded', 'failed', 'cancelled') then now() else ended_at end, updated_at = now()
-        where id = $1
-        returning *
-        `,
-        [runId, status, error ?? null]
-      );
-      if (runResult.rowCount === 0) {
-        await client.query("rollback");
-        return null;
+        return mapRawRun(currentRow);
       }
-      const run = mapRun(runResult.rows[0]);
-      const nextTaskStatus = status === "succeeded" || status === "failed" || status === "cancelled" ? status : "running";
+      const isTerminal = status === "succeeded" || status === "failed" || status === "cancelled";
+      const [updatedRun] = await tx.update(runs).set(isTerminal ? { status, error: error ?? null, endedAt: sql2`now()`, updatedAt: sql2`now()` } : { status, error: error ?? null, updatedAt: sql2`now()` }).where(eq(runs.id, runId)).returning();
+      if (!updatedRun) return null;
+      const nextTaskStatus = isTerminal ? status : "running";
       if (currentTaskStatus !== "cancelled" || status === "cancelled") {
-        await client.query("update tasks set status = $2, updated_at = now() where id = $1", [run.taskId, nextTaskStatus]);
+        await tx.update(tasks).set({ status: nextTaskStatus, updatedAt: sql2`now()` }).where(eq(tasks.id, updatedRun.taskId));
       }
-      await client.query("commit");
-      return run;
-    } catch (error2) {
-      await client.query("rollback");
-      throw error2;
-    } finally {
-      client.release();
-    }
+      return toRunRecord(updatedRun);
+    });
   }
   async appendRunLogs(runId, logs) {
-    let inserted = 0;
-    for (const log of logs) {
-      await this.pool.query(
-        `
-        insert into run_logs (run_id, step_name, stream, message)
-        values ($1, $2, $3, $4)
-        `,
-        [runId, log.stepName ?? null, log.stream, log.message]
-      );
-      inserted += 1;
-    }
-    return inserted;
+    if (logs.length === 0) return 0;
+    await this.db.insert(runLogs).values(
+      logs.map((log) => ({
+        runId,
+        stepName: log.stepName ?? null,
+        stream: log.stream,
+        message: log.message
+      }))
+    );
+    return logs.length;
   }
   async getRunLogs(runId) {
-    const result = await this.pool.query("select * from run_logs where run_id = $1 order by timestamp asc", [runId]);
-    return result.rows;
+    const rows = await this.db.select().from(runLogs).where(eq(runLogs.runId, runId)).orderBy(asc(runLogs.timestamp));
+    return rows.map(toLogRecord);
   }
   async createArtifact(runId, input) {
     const artifactId = makeId("artifact");
-    const result = await this.pool.query(
-      `
-      insert into artifacts (id, run_id, type, name, path, metadata)
-      values ($1, $2, $3, $4, $5, $6::jsonb)
-      returning *
-      `,
-      [artifactId, runId, input.type, input.name, input.path, input.metadata ? JSON.stringify(input.metadata) : null]
-    );
-    return mapArtifact(result.rows[0]);
+    const [row] = await this.db.insert(artifacts).values({
+      id: artifactId,
+      runId,
+      type: input.type,
+      name: input.name,
+      path: input.path,
+      metadata: input.metadata ?? null
+    }).returning();
+    return toArtifactRecord(row);
   }
   async listRunArtifacts(runId) {
-    const result = await this.pool.query("select * from artifacts where run_id = $1 order by created_at asc", [runId]);
-    return result.rows.map((row) => mapArtifact(row));
+    const rows = await this.db.select().from(artifacts).where(eq(artifacts.runId, runId)).orderBy(asc(artifacts.createdAt));
+    return rows.map(toArtifactRecord);
   }
   async retryTask(taskId) {
-    const result = await this.pool.query(
-      `
-      update tasks
-      set status = 'queued', updated_at = now()
-      where id = $1 and status = 'failed'
-      returning *
-      `,
-      [taskId]
-    );
-    if (result.rowCount === 0) {
-      return null;
-    }
-    return mapTask(result.rows[0]);
+    const [row] = await this.db.update(tasks).set({ status: "queued", updatedAt: sql2`now()` }).where(and(eq(tasks.id, taskId), eq(tasks.status, "failed"))).returning();
+    return row ? toTaskRecord(row) : null;
   }
   async cancelTask(taskId) {
-    const client = await this.pool.connect();
-    try {
-      await client.query("begin");
-      const taskResult = await client.query("select * from tasks where id = $1 for update", [taskId]);
-      if (taskResult.rowCount === 0) {
-        await client.query("rollback");
-        return null;
-      }
+    return await this.db.transaction(async (tx) => {
+      const taskResult = await tx.execute(sql2`
+        SELECT * FROM tasks WHERE id = ${taskId} FOR UPDATE
+      `);
+      if (taskResult.rows.length === 0) return null;
       const taskRow = taskResult.rows[0];
       const taskStatus = String(taskRow.status);
       if (taskStatus === "succeeded" || taskStatus === "failed" || taskStatus === "cancelled") {
-        await client.query("rollback");
         return null;
       }
       if (taskStatus === "assigned" || taskStatus === "running") {
-        const runResult = await client.query(
-          `
-          select * from runs
-          where task_id = $1
-          order by attempt desc
-          limit 1
-          for update
-          `,
-          [taskId]
-        );
-        if (runResult.rowCount !== 0) {
-          const runStatus = String(runResult.rows[0].status);
+        const runResult = await tx.execute(sql2`
+          SELECT * FROM runs WHERE task_id = ${taskId} ORDER BY attempt DESC LIMIT 1 FOR UPDATE
+        `);
+        if (runResult.rows.length > 0) {
+          const runRow = runResult.rows[0];
+          const runStatus = String(runRow.status);
           if (runStatus !== "succeeded" && runStatus !== "failed" && runStatus !== "cancelled") {
-            await client.query(
-              `
-              update runs
-              set status = 'cancelled', ended_at = now(), updated_at = now(), error = coalesce(error, 'task cancelled')
-              where id = $1
-              `,
-              [runResult.rows[0].id]
-            );
+            await tx.execute(sql2`
+              UPDATE runs SET status = 'cancelled', ended_at = now(), updated_at = now(),
+                error = COALESCE(error, 'task cancelled')
+              WHERE id = ${runRow.id}
+            `);
           }
         }
       }
-      const updateTaskResult = await client.query(
-        `
-        update tasks
-        set status = 'cancelled', updated_at = now()
-        where id = $1
-        returning *
-        `,
-        [taskId]
-      );
-      await client.query("commit");
-      return mapTask(updateTaskResult.rows[0]);
-    } catch (error) {
-      await client.query("rollback");
-      throw error;
-    } finally {
-      client.release();
-    }
+      const [updatedTask] = await tx.update(tasks).set({ status: "cancelled", updatedAt: sql2`now()` }).where(eq(tasks.id, taskId)).returning();
+      return toTaskRecord(updatedTask);
+    });
   }
   async appendInputEvent(runId, input) {
-    const client = await this.pool.connect();
-    try {
-      await client.query("begin");
-      const seqResult = await client.query(
-        "select coalesce(max(sequence), 0) + 1 as next_seq from run_input_events where run_id = $1",
-        [runId]
-      );
+    return await this.db.transaction(async (tx) => {
+      const seqResult = await tx.execute(sql2`
+        SELECT COALESCE(MAX(sequence), 0) + 1 AS next_seq FROM run_input_events WHERE run_id = ${runId}
+      `);
       const sequence = Number(seqResult.rows[0].next_seq);
-      const result = await client.query(
-        `
-        insert into run_input_events (run_id, sequence, kind, payload)
-        values ($1, $2, $3, $4::jsonb)
-        returning *
-        `,
-        [runId, sequence, input.kind, JSON.stringify(input.payload)]
-      );
-      await client.query("commit");
-      return mapInputEvent(result.rows[0]);
-    } catch (error) {
-      await client.query("rollback");
-      throw error;
-    } finally {
-      client.release();
-    }
+      const [inserted] = await tx.insert(runInputEvents).values({ runId, sequence, kind: input.kind, payload: input.payload }).returning();
+      return toInputEventRecord(inserted);
+    });
   }
   async getInputEvents(runId, afterSequence) {
-    const result = await this.pool.query(
-      "select * from run_input_events where run_id = $1 and sequence > $2 order by sequence asc",
-      [runId, afterSequence]
-    );
-    return result.rows.map((row) => mapInputEvent(row));
+    const rows = await this.db.select().from(runInputEvents).where(and(eq(runInputEvents.runId, runId), gt(runInputEvents.sequence, afterSequence))).orderBy(asc(runInputEvents.sequence));
+    return rows.map(toInputEventRecord);
   }
   async markInputDelivered(runId, sequence) {
-    await this.pool.query(
-      "update run_input_events set delivered_at = now() where run_id = $1 and sequence = $2",
-      [runId, sequence]
-    );
+    await this.db.update(runInputEvents).set({ deliveredAt: sql2`now()` }).where(and(eq(runInputEvents.runId, runId), eq(runInputEvents.sequence, sequence)));
   }
-  async touchNode(client, nodeId, capabilities) {
-    await client.query(
-      `
-      update nodes
-      set capabilities = $2::text[], status = 'online', last_heartbeat_at = now(), updated_at = now()
-      where id = $1
-      `,
-      [nodeId, capabilities]
+};
+
+// ../db/src/sqlite-store.ts
+import { and as and2, asc as asc2, desc as desc2, eq as eq2, gt as gt2 } from "drizzle-orm";
+
+// ../db/src/schema/sqlite.ts
+var sqlite_exports = {};
+__export(sqlite_exports, {
+  artifacts: () => artifacts2,
+  nodes: () => nodes2,
+  runInputEvents: () => runInputEvents2,
+  runLogs: () => runLogs2,
+  runs: () => runs2,
+  tasks: () => tasks2
+});
+import { isNull as isNull2, sql as sql3 } from "drizzle-orm";
+import { index as index2, integer as integer2, sqliteTable, text as text2, uniqueIndex as uniqueIndex2 } from "drizzle-orm/sqlite-core";
+var nowDefault = sql3`(strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))`;
+var tasks2 = sqliteTable("tasks", {
+  id: text2("id").primaryKey(),
+  kind: text2("kind").notNull(),
+  adapter: text2("adapter").notNull(),
+  payload: text2("payload", { mode: "json" }).$type().notNull().default({}),
+  requires: text2("requires", { mode: "json" }).$type().notNull().default([]),
+  status: text2("status").notNull(),
+  createdAt: text2("created_at").notNull().default(nowDefault),
+  updatedAt: text2("updated_at").notNull().default(nowDefault)
+}, (table) => ({
+  statusCreatedAtIdx: index2("idx_tasks_status_created_at").on(table.status, table.createdAt)
+}));
+var nodes2 = sqliteTable("nodes", {
+  id: text2("id").primaryKey(),
+  name: text2("name").notNull(),
+  capabilities: text2("capabilities", { mode: "json" }).$type().notNull().default([]),
+  status: text2("status").notNull().default("online"),
+  lastHeartbeatAt: text2("last_heartbeat_at"),
+  createdAt: text2("created_at").notNull().default(nowDefault),
+  updatedAt: text2("updated_at").notNull().default(nowDefault)
+});
+var runs2 = sqliteTable("runs", {
+  id: text2("id").primaryKey(),
+  taskId: text2("task_id").notNull().references(() => tasks2.id),
+  nodeId: text2("node_id").notNull().references(() => nodes2.id),
+  attempt: integer2("attempt").notNull(),
+  status: text2("status").notNull(),
+  startedAt: text2("started_at"),
+  endedAt: text2("ended_at"),
+  error: text2("error"),
+  createdAt: text2("created_at").notNull().default(nowDefault),
+  updatedAt: text2("updated_at").notNull().default(nowDefault)
+}, (table) => ({
+  taskIdIdx: index2("idx_runs_task_id").on(table.taskId),
+  nodeIdIdx: index2("idx_runs_node_id").on(table.nodeId)
+}));
+var runLogs2 = sqliteTable("run_logs", {
+  id: integer2("id").primaryKey({ autoIncrement: true }),
+  runId: text2("run_id").notNull().references(() => runs2.id),
+  stepName: text2("step_name"),
+  stream: text2("stream").notNull(),
+  message: text2("message").notNull(),
+  timestamp: text2("timestamp").notNull().default(nowDefault)
+}, (table) => ({
+  runIdTimestampIdx: index2("idx_run_logs_run_id_timestamp").on(table.runId, table.timestamp)
+}));
+var artifacts2 = sqliteTable("artifacts", {
+  id: text2("id").primaryKey(),
+  runId: text2("run_id").notNull().references(() => runs2.id),
+  type: text2("type").notNull(),
+  name: text2("name").notNull(),
+  path: text2("path").notNull(),
+  metadata: text2("metadata", { mode: "json" }).$type(),
+  createdAt: text2("created_at").notNull().default(nowDefault)
+}, (table) => ({
+  runIdIdx: index2("idx_artifacts_run_id").on(table.runId)
+}));
+var runInputEvents2 = sqliteTable("run_input_events", {
+  id: integer2("id").primaryKey({ autoIncrement: true }),
+  runId: text2("run_id").notNull().references(() => runs2.id),
+  sequence: integer2("sequence").notNull(),
+  kind: text2("kind").notNull(),
+  payload: text2("payload", { mode: "json" }).$type().notNull().default({}),
+  createdAt: text2("created_at").notNull().default(nowDefault),
+  deliveredAt: text2("delivered_at")
+}, (table) => ({
+  runSequenceUniqueIdx: uniqueIndex2("idx_run_input_events_run_sequence").on(table.runId, table.sequence),
+  undeliveredIdx: index2("idx_run_input_events_undelivered").on(table.runId, table.sequence).where(isNull2(table.deliveredAt))
+}));
+
+// ../db/src/sqlite-store.ts
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function toTaskRecord2(row) {
+  return {
+    id: row.id,
+    kind: row.kind,
+    adapter: row.adapter,
+    payload: row.payload,
+    requires: row.requires ?? [],
+    status: row.status,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+function toRunRecord2(row) {
+  return {
+    id: row.id,
+    taskId: row.taskId,
+    nodeId: row.nodeId,
+    attempt: row.attempt,
+    status: row.status,
+    startedAt: row.startedAt ?? null,
+    endedAt: row.endedAt ?? null,
+    error: row.error ?? null
+  };
+}
+function toNodeRecord2(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    capabilities: row.capabilities ?? [],
+    status: row.status,
+    lastHeartbeatAt: row.lastHeartbeatAt ?? null
+  };
+}
+function toLogRecord2(row) {
+  return {
+    id: row.id,
+    runId: row.runId,
+    stepName: row.stepName ?? null,
+    stream: row.stream,
+    message: row.message,
+    timestamp: row.timestamp
+  };
+}
+function toArtifactRecord2(row) {
+  return {
+    id: row.id,
+    runId: row.runId,
+    type: row.type,
+    name: row.name,
+    path: row.path,
+    metadata: row.metadata ?? null,
+    createdAt: row.createdAt
+  };
+}
+function toInputEventRecord2(row) {
+  return {
+    id: row.id,
+    runId: row.runId,
+    sequence: row.sequence,
+    kind: row.kind,
+    payload: row.payload,
+    createdAt: row.createdAt,
+    deliveredAt: row.deliveredAt ?? null
+  };
+}
+function mapRawTask2(row) {
+  return {
+    id: row.id,
+    kind: row.kind,
+    adapter: row.adapter,
+    payload: JSON.parse(row.payload),
+    requires: JSON.parse(row.requires),
+    status: row.status,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function mapRawRun2(row) {
+  return {
+    id: row.id,
+    taskId: row.task_id,
+    nodeId: row.node_id,
+    attempt: row.attempt,
+    status: row.status,
+    startedAt: row.started_at ?? null,
+    endedAt: row.ended_at ?? null,
+    error: row.error ?? null
+  };
+}
+var SqliteStore = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  async createTask(input) {
+    const now = nowIso();
+    const [row] = await this.db.insert(tasks2).values({
+      id: makeId("task"),
+      kind: input.kind,
+      adapter: input.adapter,
+      payload: input.payload,
+      requires: input.requires ?? [],
+      status: "queued",
+      createdAt: now,
+      updatedAt: now
+    }).returning();
+    return toTaskRecord2(row);
+  }
+  async listTasks(status) {
+    const rows = await this.db.select().from(tasks2).where(status ? eq2(tasks2.status, status) : void 0).orderBy(desc2(tasks2.createdAt)).limit(100);
+    return rows.map(toTaskRecord2);
+  }
+  async getTask(taskId) {
+    const [row] = await this.db.select().from(tasks2).where(eq2(tasks2.id, taskId));
+    return row ? toTaskRecord2(row) : null;
+  }
+  async listRuns(filters) {
+    const conds = [];
+    if (filters?.taskId) conds.push(eq2(runs2.taskId, filters.taskId));
+    if (filters?.status) conds.push(eq2(runs2.status, filters.status));
+    const rows = await this.db.select().from(runs2).where(conds.length ? and2(...conds) : void 0).orderBy(desc2(runs2.createdAt)).limit(100);
+    return rows.map(toRunRecord2);
+  }
+  async getRun(runId) {
+    const [row] = await this.db.select().from(runs2).where(eq2(runs2.id, runId));
+    return row ? toRunRecord2(row) : null;
+  }
+  async registerNode(name, capabilities, preferredId) {
+    const now = nowIso();
+    const [existing] = await this.db.select().from(nodes2).where(eq2(nodes2.name, name));
+    if (existing) {
+      const [updated] = await this.db.update(nodes2).set({ capabilities, status: "online", lastHeartbeatAt: now, updatedAt: now }).where(eq2(nodes2.id, existing.id)).returning();
+      return toNodeRecord2(updated);
+    }
+    const [inserted] = await this.db.insert(nodes2).values({
+      id: preferredId ?? makeId("node"),
+      name,
+      capabilities,
+      status: "online",
+      lastHeartbeatAt: now,
+      createdAt: now,
+      updatedAt: now
+    }).returning();
+    return toNodeRecord2(inserted);
+  }
+  async getRunCancellationState(runId) {
+    const [row] = await this.db.select({ runStatus: runs2.status, taskStatus: tasks2.status }).from(runs2).innerJoin(tasks2, eq2(tasks2.id, runs2.taskId)).where(eq2(runs2.id, runId));
+    return row ? { runStatus: row.runStatus, taskStatus: row.taskStatus ?? "" } : null;
+  }
+  // Transaction methods use this.db.$client directly because better-sqlite3
+  // rejects async callbacks — all operations inside must be synchronous.
+  async pollNode(nodeId, capabilities) {
+    const now = nowIso();
+    await this.db.update(nodes2).set({ capabilities, status: "online", lastHeartbeatAt: now, updatedAt: now }).where(eq2(nodes2.id, nodeId));
+    const raw = this.db.$client;
+    return raw.transaction(() => {
+      const capSet = new Set(capabilities);
+      const queued = raw.prepare(
+        "SELECT * FROM tasks WHERE status = 'queued' ORDER BY created_at ASC"
+      ).all();
+      const task = queued.find(
+        (t) => JSON.parse(t.requires).every((r) => capSet.has(r))
+      );
+      if (!task) return null;
+      const { max_attempt } = raw.prepare(
+        "SELECT COALESCE(MAX(attempt), 0) AS max_attempt FROM runs WHERE task_id = ?"
+      ).get(task.id);
+      const runId = makeId("run");
+      raw.prepare(
+        "INSERT INTO runs (id, task_id, node_id, attempt, status, started_at, created_at, updated_at) VALUES (?, ?, ?, ?, 'assigned', ?, ?, ?)"
+      ).run(runId, task.id, nodeId, max_attempt + 1, now, now, now);
+      raw.prepare("UPDATE tasks SET status = 'assigned', updated_at = ? WHERE id = ?").run(now, task.id);
+      return {
+        task: mapRawTask2(task),
+        run: mapRawRun2(raw.prepare("SELECT * FROM runs WHERE id = ?").get(runId))
+      };
+    })();
+  }
+  async updateRunStatus(runId, status, error) {
+    const raw = this.db.$client;
+    return raw.transaction(() => {
+      const current = raw.prepare(
+        "SELECT r.*, t.status AS task_status FROM runs r JOIN tasks t ON t.id = r.task_id WHERE r.id = ?"
+      ).get(runId);
+      if (!current) return null;
+      if (current.task_status === "cancelled" && status !== "cancelled") {
+        return mapRawRun2(current);
+      }
+      const now = nowIso();
+      const isTerminal = status === "succeeded" || status === "failed" || status === "cancelled";
+      if (isTerminal) {
+        raw.prepare(
+          "UPDATE runs SET status = ?, error = ?, ended_at = ?, updated_at = ? WHERE id = ?"
+        ).run(status, error ?? null, now, now, runId);
+      } else {
+        raw.prepare(
+          "UPDATE runs SET status = ?, error = ?, updated_at = ? WHERE id = ?"
+        ).run(status, error ?? null, now, runId);
+      }
+      const updatedRun = raw.prepare("SELECT * FROM runs WHERE id = ?").get(runId);
+      const nextTaskStatus = isTerminal ? status : "running";
+      if (current.task_status !== "cancelled" || status === "cancelled") {
+        raw.prepare("UPDATE tasks SET status = ?, updated_at = ? WHERE id = ?").run(
+          nextTaskStatus,
+          now,
+          updatedRun.task_id
+        );
+      }
+      return mapRawRun2(updatedRun);
+    })();
+  }
+  async appendRunLogs(runId, logs) {
+    if (logs.length === 0) return 0;
+    const now = nowIso();
+    await this.db.insert(runLogs2).values(
+      logs.map((log) => ({
+        runId,
+        stepName: log.stepName ?? null,
+        stream: log.stream,
+        message: log.message,
+        timestamp: now
+      }))
     );
+    return logs.length;
+  }
+  async getRunLogs(runId) {
+    const rows = await this.db.select().from(runLogs2).where(eq2(runLogs2.runId, runId)).orderBy(asc2(runLogs2.timestamp));
+    return rows.map(toLogRecord2);
+  }
+  async createArtifact(runId, input) {
+    const now = nowIso();
+    const [row] = await this.db.insert(artifacts2).values({
+      id: makeId("artifact"),
+      runId,
+      type: input.type,
+      name: input.name,
+      path: input.path,
+      metadata: input.metadata ?? null,
+      createdAt: now
+    }).returning();
+    return toArtifactRecord2(row);
+  }
+  async listRunArtifacts(runId) {
+    const rows = await this.db.select().from(artifacts2).where(eq2(artifacts2.runId, runId)).orderBy(asc2(artifacts2.createdAt));
+    return rows.map(toArtifactRecord2);
+  }
+  async retryTask(taskId) {
+    const [row] = await this.db.update(tasks2).set({ status: "queued", updatedAt: nowIso() }).where(and2(eq2(tasks2.id, taskId), eq2(tasks2.status, "failed"))).returning();
+    return row ? toTaskRecord2(row) : null;
+  }
+  async cancelTask(taskId) {
+    const raw = this.db.$client;
+    return raw.transaction(() => {
+      const taskRow = raw.prepare("SELECT * FROM tasks WHERE id = ?").get(taskId);
+      if (!taskRow) return null;
+      const terminal = /* @__PURE__ */ new Set(["succeeded", "failed", "cancelled"]);
+      if (terminal.has(taskRow.status)) return null;
+      const now = nowIso();
+      if (taskRow.status === "assigned" || taskRow.status === "running") {
+        const latestRun = raw.prepare(
+          "SELECT * FROM runs WHERE task_id = ? ORDER BY attempt DESC LIMIT 1"
+        ).get(taskId);
+        if (latestRun && !terminal.has(latestRun.status)) {
+          raw.prepare(
+            "UPDATE runs SET status = 'cancelled', ended_at = ?, updated_at = ?, error = COALESCE(error, 'task cancelled') WHERE id = ?"
+          ).run(now, now, latestRun.id);
+        }
+      }
+      raw.prepare("UPDATE tasks SET status = 'cancelled', updated_at = ? WHERE id = ?").run(now, taskId);
+      return mapRawTask2(raw.prepare("SELECT * FROM tasks WHERE id = ?").get(taskId));
+    })();
+  }
+  async appendInputEvent(runId, input) {
+    const raw = this.db.$client;
+    const now = nowIso();
+    const event = raw.transaction(() => {
+      const { next_seq } = raw.prepare(
+        "SELECT COALESCE(MAX(sequence), 0) + 1 AS next_seq FROM run_input_events WHERE run_id = ?"
+      ).get(runId);
+      raw.prepare(
+        "INSERT INTO run_input_events (run_id, sequence, kind, payload, created_at) VALUES (?, ?, ?, ?, ?)"
+      ).run(runId, next_seq, input.kind, JSON.stringify(input.payload), now);
+      return raw.prepare(
+        "SELECT * FROM run_input_events WHERE run_id = ? AND sequence = ?"
+      ).get(runId, next_seq);
+    })();
+    return {
+      id: event.id,
+      runId: event.run_id,
+      sequence: event.sequence,
+      kind: event.kind,
+      payload: JSON.parse(event.payload),
+      createdAt: event.created_at,
+      deliveredAt: event.delivered_at ?? null
+    };
+  }
+  async getInputEvents(runId, afterSequence) {
+    const rows = await this.db.select().from(runInputEvents2).where(and2(eq2(runInputEvents2.runId, runId), gt2(runInputEvents2.sequence, afterSequence))).orderBy(asc2(runInputEvents2.sequence));
+    return rows.map(toInputEventRecord2);
+  }
+  async markInputDelivered(runId, sequence) {
+    await this.db.update(runInputEvents2).set({ deliveredAt: nowIso() }).where(and2(eq2(runInputEvents2.runId, runId), eq2(runInputEvents2.sequence, sequence)));
   }
 };
 
+// ../db/src/client.ts
+var pools = /* @__PURE__ */ new Map();
+function getPool(databaseUrl) {
+  const existing = pools.get(databaseUrl);
+  if (existing) return existing;
+  const pool = new Pool({ connectionString: databaseUrl });
+  pools.set(databaseUrl, pool);
+  return pool;
+}
+function getDrizzle(pool) {
+  return drizzlePg(pool, { schema: pg_exports });
+}
+function parseSqlitePath(url) {
+  const path = url.startsWith("sqlite://") ? url.slice("sqlite://".length) : url;
+  if (!path) return join2(homedir2(), ".workplane", "workplane.db");
+  if (path.startsWith("~/")) return join2(homedir2(), path.slice(2));
+  return path;
+}
+function createStore(databaseUrl) {
+  const url = databaseUrl ?? "";
+  if (url.startsWith("postgres://") || url.startsWith("postgresql://")) {
+    const pool = getPool(url);
+    return {
+      store: new PgStore(getDrizzle(pool)),
+      close: () => pool.end()
+    };
+  }
+  const filePath = parseSqlitePath(url);
+  mkdirSync(dirname(filePath), { recursive: true });
+  const sqlite = new Database(filePath);
+  sqlite.pragma("journal_mode = WAL");
+  sqlite.pragma("synchronous = NORMAL");
+  const db = drizzleSqlite(sqlite, { schema: sqlite_exports });
+  return {
+    store: new SqliteStore(db),
+    close: async () => {
+      sqlite.close();
+    }
+  };
+}
+
 // ../server/src/workflows-vanilla.ts
 var VanillaWorkflows = class {
   constructor(store) {
@@ -856,8 +1265,7 @@ async function buildWorkflows(store, config) {
 }
 async function main() {
   const config = loadServerConfig();
-  const pool = getPool(config.databaseUrl);
-  const store = new PgStore(pool);
+  const { store, close: closeStore } = createStore(config.databaseUrl);
   const { workflows, shutdown: shutdownWorkflows } = await buildWorkflows(store, config);
   const server = createServer(async (req, res) => {
     try {
@@ -889,8 +1297,8 @@ async function main() {
       }
       if (req.method === "GET" && url.pathname === "/tasks") {
         const status = parseStatus(url.searchParams.get("status"));
-        const tasks = await store.listTasks(status);
-        writeJson(res, 200, { tasks });
+        const tasks3 = await store.listTasks(status);
+        writeJson(res, 200, { tasks: tasks3 });
         return;
       }
       if (req.method === "GET" && /^\/tasks\/[^/]+$/.test(url.pathname)) {
@@ -926,8 +1334,8 @@ async function main() {
       if (req.method === "GET" && url.pathname === "/runs") {
         const taskId = url.searchParams.get("taskId") ?? void 0;
         const status = parseStatus(url.searchParams.get("status"));
-        const runs = await store.listRuns({ taskId, status });
-        writeJson(res, 200, { runs });
+        const runs3 = await store.listRuns({ taskId, status });
+        writeJson(res, 200, { runs: runs3 });
         return;
       }
       if (req.method === "GET" && /^\/runs\/[^/]+$/.test(url.pathname)) {
@@ -948,8 +1356,8 @@ async function main() {
       }
       if (req.method === "GET" && /^\/runs\/[^/]+\/artifacts$/.test(url.pathname)) {
         const runId = url.pathname.split("/")[2];
-        const artifacts = await store.listRunArtifacts(runId);
-        writeJson(res, 200, { artifacts });
+        const artifacts3 = await store.listRunArtifacts(runId);
+        writeJson(res, 200, { artifacts: artifacts3 });
         return;
       }
       if (req.method === "POST" && url.pathname === "/nodes/register") {
@@ -1042,7 +1450,7 @@ async function main() {
   });
   const shutdown = async () => {
     await shutdownWorkflows();
-    await pool.end();
+    await closeStore();
     server.close();
     process.exit(0);
   };