stagent 0.6.3 → 0.8.0

package/src/lib/data/tables.ts

@@ -0,0 +1,417 @@
+import { randomUUID } from "crypto";
+import { db } from "@/lib/db";
+import { eq, and, like, or, desc, sql, count } from "drizzle-orm";
+import {
+  userTables,
+  userTableColumns,
+  userTableRows,
+  userTableTemplates,
+  projects,
+} from "@/lib/db/schema";
+import type {
+  CreateTableInput,
+  UpdateTableInput,
+  AddColumnInput,
+  UpdateColumnInput,
+  AddRowInput,
+  UpdateRowInput,
+  ColumnDef,
+  RowQueryOptions,
+  CloneFromTemplateInput,
+} from "@/lib/tables/types";
+import { buildRowQuery } from "@/lib/tables/query-builder";
+
+// ── Table CRUD ───────────────────────────────────────────────────────
+
+export async function createTable(input: CreateTableInput) {
+  const id = randomUUID();
+  const now = new Date();
+
+  // Build column schema from input columns
+  const columns = (input.columns ?? []).map((col, i) => ({
+    ...col,
+    position: col.position ?? i,
+  }));
+
+  await db.insert(userTables).values({
+    id,
+    name: input.name,
+    description: input.description ?? null,
+    projectId: input.projectId ?? null,
+    columnSchema: JSON.stringify(columns),
+    rowCount: 0,
+    source: input.source ?? "manual",
+    templateId: input.templateId ?? null,
+    createdAt: now,
+    updatedAt: now,
+  });
+
+  // Create individual column records
+  if (columns.length > 0) {
+    await db.insert(userTableColumns).values(
+      columns.map((col) => ({
+        id: randomUUID(),
+        tableId: id,
+        name: col.name,
+        displayName: col.displayName,
+        dataType: col.dataType,
+        position: col.position,
+        required: col.required ?? false,
+        defaultValue: col.defaultValue ?? null,
+        config: col.config ? JSON.stringify(col.config) : null,
+        createdAt: now,
+        updatedAt: now,
+      }))
+    );
+  }
+
+  return db.select().from(userTables).where(eq(userTables.id, id)).get()!;
+}
+
+export async function getTable(id: string) {
+  return db.select().from(userTables).where(eq(userTables.id, id)).get() ?? null;
+}
+
+export async function listTables(filters?: {
+  projectId?: string;
+  source?: string;
+  search?: string;
+}) {
+  const conditions = [];
+  if (filters?.projectId) {
+    conditions.push(eq(userTables.projectId, filters.projectId));
+  }
+  if (filters?.source) {
+    conditions.push(eq(userTables.source, filters.source as "manual" | "imported" | "agent" | "template"));
+  }
+  if (filters?.search) {
+    conditions.push(
+      or(
+        like(userTables.name, `%${filters.search}%`),
+        like(userTables.description, `%${filters.search}%`)
+      )
+    );
+  }
+
+  const rows = db
+    .select({
+      table: userTables,
+      projectName: projects.name,
+    })
+    .from(userTables)
+    .leftJoin(projects, eq(userTables.projectId, projects.id))
+    .where(conditions.length > 0 ? and(...conditions) : undefined)
+    .orderBy(desc(userTables.updatedAt))
+    .all();
+
+  return rows.map((r) => ({
+    ...r.table,
+    projectName: r.projectName,
+    columnCount: parseColumnSchema(r.table.columnSchema).length,
+  }));
+}
+
+export async function updateTable(id: string, updates: UpdateTableInput) {
+  await db
+    .update(userTables)
+    .set({ ...updates, updatedAt: new Date() })
+    .where(eq(userTables.id, id));
+
+  return db.select().from(userTables).where(eq(userTables.id, id)).get() ?? null;
+}
+
+export async function deleteTable(id: string) {
+  // FK-safe: delete children first
+  await db.delete(userTableRows).where(eq(userTableRows.tableId, id));
+  await db.delete(userTableColumns).where(eq(userTableColumns.tableId, id));
+  await db.delete(userTables).where(eq(userTables.id, id));
+}
+
+// ── Column CRUD ──────────────────────────────────────────────────────
+
+export async function getColumns(tableId: string) {
+  return db
+    .select()
+    .from(userTableColumns)
+    .where(eq(userTableColumns.tableId, tableId))
+    .orderBy(userTableColumns.position)
+    .all();
+}
+
+export async function addColumn(tableId: string, input: AddColumnInput) {
+  const id = randomUUID();
+  const now = new Date();
+
+  // Get current max position
+  const existing = await getColumns(tableId);
+  const position = existing.length;
+
+  await db.insert(userTableColumns).values({
+    id,
+    tableId,
+    name: input.name,
+    displayName: input.displayName,
+    dataType: input.dataType,
+    position,
+    required: input.required ?? false,
+    defaultValue: input.defaultValue ?? null,
+    config: input.config ? JSON.stringify(input.config) : null,
+    createdAt: now,
+    updatedAt: now,
+  });
+
+  // Update the denormalized column_schema on the table
+  await syncColumnSchema(tableId);
+
+  return db.select().from(userTableColumns).where(eq(userTableColumns.id, id)).get()!;
+}
+
+export async function updateColumn(columnId: string, input: UpdateColumnInput) {
+  const now = new Date();
+  const updates: Record<string, unknown> = { updatedAt: now };
+  if (input.displayName !== undefined) updates.displayName = input.displayName;
+  if (input.dataType !== undefined) updates.dataType = input.dataType;
+  if (input.required !== undefined) updates.required = input.required;
+  if (input.defaultValue !== undefined) updates.defaultValue = input.defaultValue;
+  if (input.config !== undefined) updates.config = input.config ? JSON.stringify(input.config) : null;
+
+  await db.update(userTableColumns).set(updates).where(eq(userTableColumns.id, columnId));
+
+  // Get column to find table ID for schema sync
+  const col = db.select().from(userTableColumns).where(eq(userTableColumns.id, columnId)).get();
+  if (col) await syncColumnSchema(col.tableId);
+
+  return col ?? null;
+}
+
+export async function deleteColumn(columnId: string) {
+  const col = db.select().from(userTableColumns).where(eq(userTableColumns.id, columnId)).get();
+  if (!col) return;
+
+  await db.delete(userTableColumns).where(eq(userTableColumns.id, columnId));
+  await syncColumnSchema(col.tableId);
+}
+
+export async function reorderColumns(tableId: string, columnIds: string[]) {
+  const now = new Date();
+  for (let i = 0; i < columnIds.length; i++) {
+    await db
+      .update(userTableColumns)
+      .set({ position: i, updatedAt: now })
+      .where(eq(userTableColumns.id, columnIds[i]));
+  }
+  await syncColumnSchema(tableId);
+}
+
+/** Sync the denormalized column_schema JSON on user_tables from user_table_columns */
+async function syncColumnSchema(tableId: string) {
+  const columns = await getColumns(tableId);
+  const schema: ColumnDef[] = columns.map((c) => ({
+    name: c.name,
+    displayName: c.displayName,
+    dataType: c.dataType as ColumnDef["dataType"],
+    position: c.position,
+    required: c.required,
+    defaultValue: c.defaultValue,
+    config: c.config ? JSON.parse(c.config) : null,
+  }));
+
+  await db
+    .update(userTables)
+    .set({ columnSchema: JSON.stringify(schema), updatedAt: new Date() })
+    .where(eq(userTables.id, tableId));
+}
+
+// ── Row History & Triggers ──────────────────────────────────────────
+import { snapshotBeforeUpdate, snapshotBeforeDelete } from "@/lib/tables/history";
+import { evaluateTriggers } from "@/lib/tables/trigger-evaluator";
+
+// ── Row CRUD ─────────────────────────────────────────────────────────
+
+export async function addRows(tableId: string, rows: AddRowInput[]) {
+  const now = new Date();
+
+  // Get current max position
+  const maxPos = db
+    .select({ maxPos: sql<number>`COALESCE(MAX(position), -1)` })
+    .from(userTableRows)
+    .where(eq(userTableRows.tableId, tableId))
+    .get();
+  let nextPosition = (maxPos?.maxPos ?? -1) + 1;
+
+  const ids: string[] = [];
+  for (const row of rows) {
+    const id = randomUUID();
+    ids.push(id);
+    await db.insert(userTableRows).values({
+      id,
+      tableId,
+      data: JSON.stringify(row.data),
+      position: nextPosition++,
+      createdBy: row.createdBy ?? "user",
+      createdAt: now,
+      updatedAt: now,
+    });
+  }
+
+  // Update denormalized row count
+  await updateRowCount(tableId);
+
+  // Fire triggers for new rows (fire-and-forget)
+  for (const [i] of rows.entries()) {
+    evaluateTriggers(tableId, "row_added", rows[i].data).catch(() => {});
+  }
+
+  return ids;
+}
+
+export async function getRow(rowId: string) {
+  return db.select().from(userTableRows).where(eq(userTableRows.id, rowId)).get() ?? null;
+}
+
+export async function listRows(tableId: string, options?: RowQueryOptions) {
+  const table = await getTable(tableId);
+  if (!table) return [];
+
+  const columnSchema = parseColumnSchema(table.columnSchema);
+  const query = buildRowQuery(columnSchema, options ?? {});
+
+  const whereClause = query.where
+    ? and(eq(userTableRows.tableId, tableId), query.where)
+    : eq(userTableRows.tableId, tableId);
+
+  const orderClause = query.orderBy ?? userTableRows.position;
+
+  return db
+    .select()
+    .from(userTableRows)
+    .where(whereClause)
+    .orderBy(orderClause)
+    .limit(query.limit)
+    .offset(query.offset)
+    .all();
+}
+
+export async function updateRow(rowId: string, input: UpdateRowInput) {
+  const existing = await getRow(rowId);
+  if (!existing) return null;
+
+  // Snapshot before mutation (non-blocking)
+  try { snapshotBeforeUpdate(rowId, existing.tableId, existing.data, "user"); } catch { /* history is non-critical */ }
+
+  // Merge new data with existing data
+  const existingData = JSON.parse(existing.data) as Record<string, unknown>;
+  const mergedData = { ...existingData, ...input.data };
+
+  await db
+    .update(userTableRows)
+    .set({
+      data: JSON.stringify(mergedData),
+      updatedAt: new Date(),
+    })
+    .where(eq(userTableRows.id, rowId));
+
+  // Fire triggers (fire-and-forget)
+  evaluateTriggers(existing.tableId, "row_updated", mergedData).catch(() => {});
+
+  return db.select().from(userTableRows).where(eq(userTableRows.id, rowId)).get() ?? null;
+}
+
+export async function deleteRows(rowIds: string[]) {
+  if (rowIds.length === 0) return;
+
+  // Get table ID from first row to update count after
+  const firstRow = await getRow(rowIds[0]);
+  if (!firstRow) return;
+
+  for (const id of rowIds) {
+    const row = await getRow(id);
+    if (row) {
+      // Snapshot before deletion (non-blocking)
+      try { snapshotBeforeDelete(id, row.tableId, row.data, "user"); } catch { /* history is non-critical */ }
+      // Fire trigger before row is gone (fire-and-forget)
+      evaluateTriggers(row.tableId, "row_deleted", JSON.parse(row.data) as Record<string, unknown>).catch(() => {});
+    }
+    await db.delete(userTableRows).where(eq(userTableRows.id, id));
+  }
+
+  await updateRowCount(firstRow.tableId);
+}
+
+/** Update the denormalized row_count on user_tables */
+async function updateRowCount(tableId: string) {
+  const result = db
+    .select({ total: count() })
+    .from(userTableRows)
+    .where(eq(userTableRows.tableId, tableId))
+    .get();
+
+  await db
+    .update(userTables)
+    .set({ rowCount: result?.total ?? 0, updatedAt: new Date() })
+    .where(eq(userTables.id, tableId));
+}
+
+// ── Template Operations ──────────────────────────────────────────────
+
+export async function listTemplates(filters?: {
+  category?: string;
+  scope?: string;
+}) {
+  const conditions = [];
+  if (filters?.category) {
+    conditions.push(eq(userTableTemplates.category, filters.category as "business" | "personal" | "pm" | "finance" | "content"));
+  }
+  if (filters?.scope) {
+    conditions.push(eq(userTableTemplates.scope, filters.scope as "system" | "user"));
+  }
+
+  return db
+    .select()
+    .from(userTableTemplates)
+    .where(conditions.length > 0 ? and(...conditions) : undefined)
+    .orderBy(userTableTemplates.name)
+    .all();
+}
+
+export async function getTemplate(id: string) {
+  return db.select().from(userTableTemplates).where(eq(userTableTemplates.id, id)).get() ?? null;
+}
+
+export async function cloneFromTemplate(input: CloneFromTemplateInput) {
+  const template = await getTemplate(input.templateId);
+  if (!template) throw new Error("Template not found");
+
+  const columns = parseColumnSchema(template.columnSchema);
+
+  const table = await createTable({
+    name: input.name,
+    projectId: input.projectId,
+    columns,
+    source: "template",
+    templateId: template.id,
+  });
+
+  // Optionally insert sample data
+  if (input.includeSampleData && template.sampleData) {
+    const sampleRows = JSON.parse(template.sampleData) as Record<string, unknown>[];
+    if (sampleRows.length > 0) {
+      await addRows(
+        table.id,
+        sampleRows.map((data) => ({ data }))
+      );
+    }
+  }
+
+  return table;
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────
+
+function parseColumnSchema(raw: string): ColumnDef[] {
+  try {
+    return JSON.parse(raw) as ColumnDef[];
+  } catch {
+    return [];
+  }
+}

package/src/lib/db/bootstrap.ts

@@ -31,6 +31,20 @@ const STAGENT_TABLES = [
   "workflow_document_inputs",
   "schedule_document_inputs",
   "project_document_defaults",
+  "user_tables",
+  "user_table_columns",
+  "user_table_rows",
+  "user_table_views",
+  "user_table_relationships",
+  "user_table_templates",
+  "user_table_imports",
+  "table_document_inputs",
+  "task_table_inputs",
+  "workflow_table_inputs",
+  "schedule_table_inputs",
+  "user_table_triggers",
+  "user_table_row_history",
+  "snapshots",
 ] as const;
 
 export function bootstrapStagentDatabase(sqlite: Database.Database): void {
@@ -614,6 +628,219 @@ export function bootstrapStagentDatabase(sqlite: Database.Database): void {
     CREATE INDEX IF NOT EXISTS idx_pdd_project ON project_document_defaults(project_id);
     CREATE UNIQUE INDEX IF NOT EXISTS idx_pdd_project_doc ON project_document_defaults(project_id, document_id);
   `);
+
+  // ── User-Defined Tables (structured data) ──────────────────────────────
+  sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS user_tables (
+      id TEXT PRIMARY KEY NOT NULL,
+      project_id TEXT,
+      name TEXT NOT NULL,
+      description TEXT,
+      column_schema TEXT NOT NULL DEFAULT '[]',
+      row_count INTEGER DEFAULT 0 NOT NULL,
+      source TEXT DEFAULT 'manual' NOT NULL,
+      template_id TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      FOREIGN KEY (project_id) REFERENCES projects(id) ON UPDATE NO ACTION ON DELETE NO ACTION
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_user_tables_project_id ON user_tables(project_id);
+    CREATE INDEX IF NOT EXISTS idx_user_tables_source ON user_tables(source);
+
+    CREATE TABLE IF NOT EXISTS user_table_columns (
+      id TEXT PRIMARY KEY NOT NULL,
+      table_id TEXT NOT NULL,
+      name TEXT NOT NULL,
+      display_name TEXT NOT NULL,
+      data_type TEXT NOT NULL,
+      position INTEGER NOT NULL,
+      required INTEGER DEFAULT 0 NOT NULL,
+      default_value TEXT,
+      config TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      FOREIGN KEY (table_id) REFERENCES user_tables(id) ON UPDATE NO ACTION ON DELETE NO ACTION
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_user_table_columns_table_id ON user_table_columns(table_id);
+    CREATE INDEX IF NOT EXISTS idx_user_table_columns_position ON user_table_columns(table_id, position);
+
+    CREATE TABLE IF NOT EXISTS user_table_rows (
+      id TEXT PRIMARY KEY NOT NULL,
+      table_id TEXT NOT NULL,
+      data TEXT NOT NULL DEFAULT '{}',
+      position INTEGER NOT NULL,
+      created_by TEXT DEFAULT 'user',
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      FOREIGN KEY (table_id) REFERENCES user_tables(id) ON UPDATE NO ACTION ON DELETE NO ACTION
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_user_table_rows_table_id ON user_table_rows(table_id);
+    CREATE INDEX IF NOT EXISTS idx_user_table_rows_position ON user_table_rows(table_id, position);
+
+    CREATE TABLE IF NOT EXISTS user_table_views (
+      id TEXT PRIMARY KEY NOT NULL,
+      table_id TEXT NOT NULL,
+      name TEXT NOT NULL,
+      type TEXT DEFAULT 'grid' NOT NULL,
+      config TEXT,
+      is_default INTEGER DEFAULT 0 NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      FOREIGN KEY (table_id) REFERENCES user_tables(id) ON UPDATE NO ACTION ON DELETE NO ACTION
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_user_table_views_table_id ON user_table_views(table_id);
+
+    CREATE TABLE IF NOT EXISTS user_table_relationships (
+      id TEXT PRIMARY KEY NOT NULL,
+      from_table_id TEXT NOT NULL,
+      from_column TEXT NOT NULL,
+      to_table_id TEXT NOT NULL,
+      to_column TEXT NOT NULL,
+      relationship_type TEXT NOT NULL,
+      config TEXT,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (from_table_id) REFERENCES user_tables(id) ON UPDATE NO ACTION ON DELETE NO ACTION,
+      FOREIGN KEY (to_table_id) REFERENCES user_tables(id) ON UPDATE NO ACTION ON DELETE NO ACTION
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_user_table_rels_from ON user_table_relationships(from_table_id);
+    CREATE INDEX IF NOT EXISTS idx_user_table_rels_to ON user_table_relationships(to_table_id);
+
+    CREATE TABLE IF NOT EXISTS user_table_templates (
+      id TEXT PRIMARY KEY NOT NULL,
+      name TEXT NOT NULL,
+      description TEXT,
+      category TEXT NOT NULL,
+      column_schema TEXT NOT NULL,
+      sample_data TEXT,
+      scope TEXT DEFAULT 'system' NOT NULL,
+      icon TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_user_table_templates_category ON user_table_templates(category);
+    CREATE INDEX IF NOT EXISTS idx_user_table_templates_scope ON user_table_templates(scope);
+
+    CREATE TABLE IF NOT EXISTS user_table_imports (
+      id TEXT PRIMARY KEY NOT NULL,
+      table_id TEXT NOT NULL,
+      document_id TEXT,
+      row_count INTEGER DEFAULT 0 NOT NULL,
+      error_count INTEGER DEFAULT 0 NOT NULL,
+      errors TEXT,
+      status TEXT DEFAULT 'pending' NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (table_id) REFERENCES user_tables(id) ON UPDATE NO ACTION ON DELETE NO ACTION,
+      FOREIGN KEY (document_id) REFERENCES documents(id) ON UPDATE NO ACTION ON DELETE NO ACTION
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_user_table_imports_table_id ON user_table_imports(table_id);
+
+    CREATE TABLE IF NOT EXISTS table_document_inputs (
+      id TEXT PRIMARY KEY NOT NULL,
+      table_id TEXT NOT NULL,
+      document_id TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (table_id) REFERENCES user_tables(id) ON UPDATE NO ACTION ON DELETE NO ACTION,
+      FOREIGN KEY (document_id) REFERENCES documents(id) ON UPDATE NO ACTION ON DELETE NO ACTION
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_tdi_table ON table_document_inputs(table_id);
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_tdi_table_doc ON table_document_inputs(table_id, document_id);
+
+    CREATE TABLE IF NOT EXISTS task_table_inputs (
+      id TEXT PRIMARY KEY NOT NULL,
+      task_id TEXT NOT NULL,
+      table_id TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (task_id) REFERENCES tasks(id) ON UPDATE NO ACTION ON DELETE NO ACTION,
+      FOREIGN KEY (table_id) REFERENCES user_tables(id) ON UPDATE NO ACTION ON DELETE NO ACTION
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_tti_task ON task_table_inputs(task_id);
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_tti_task_table ON task_table_inputs(task_id, table_id);
+
+    CREATE TABLE IF NOT EXISTS workflow_table_inputs (
+      id TEXT PRIMARY KEY NOT NULL,
+      workflow_id TEXT NOT NULL,
+      table_id TEXT NOT NULL,
+      step_id TEXT,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (workflow_id) REFERENCES workflows(id) ON UPDATE NO ACTION ON DELETE NO ACTION,
+      FOREIGN KEY (table_id) REFERENCES user_tables(id) ON UPDATE NO ACTION ON DELETE NO ACTION
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_wti_workflow ON workflow_table_inputs(workflow_id);
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_wti_workflow_table_step ON workflow_table_inputs(workflow_id, table_id, step_id);
+
+    CREATE TABLE IF NOT EXISTS schedule_table_inputs (
+      id TEXT PRIMARY KEY NOT NULL,
+      schedule_id TEXT NOT NULL,
+      table_id TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (schedule_id) REFERENCES schedules(id) ON UPDATE NO ACTION ON DELETE NO ACTION,
+      FOREIGN KEY (table_id) REFERENCES user_tables(id) ON UPDATE NO ACTION ON DELETE NO ACTION
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_sti_schedule ON schedule_table_inputs(schedule_id);
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_sti_schedule_table ON schedule_table_inputs(schedule_id, table_id);
+
+    CREATE TABLE IF NOT EXISTS user_table_triggers (
+      id TEXT PRIMARY KEY NOT NULL,
+      table_id TEXT NOT NULL,
+      name TEXT NOT NULL,
+      trigger_event TEXT NOT NULL,
+      condition TEXT,
+      action_type TEXT NOT NULL,
+      action_config TEXT NOT NULL,
+      status TEXT DEFAULT 'active' NOT NULL,
+      fire_count INTEGER DEFAULT 0 NOT NULL,
+      last_fired_at INTEGER,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      FOREIGN KEY (table_id) REFERENCES user_tables(id) ON UPDATE NO ACTION ON DELETE NO ACTION
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_user_table_triggers_table_id ON user_table_triggers(table_id);
+    CREATE INDEX IF NOT EXISTS idx_user_table_triggers_status ON user_table_triggers(status);
+
+    CREATE TABLE IF NOT EXISTS user_table_row_history (
+      id TEXT PRIMARY KEY NOT NULL,
+      row_id TEXT NOT NULL,
+      table_id TEXT NOT NULL,
+      previous_data TEXT NOT NULL,
+      changed_by TEXT DEFAULT 'user',
+      change_type TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (table_id) REFERENCES user_tables(id) ON UPDATE NO ACTION ON DELETE NO ACTION
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_row_history_row_id ON user_table_row_history(row_id);
+    CREATE INDEX IF NOT EXISTS idx_row_history_table_id ON user_table_row_history(table_id);
+    CREATE INDEX IF NOT EXISTS idx_row_history_created_at ON user_table_row_history(created_at);
+
+    CREATE TABLE IF NOT EXISTS snapshots (
+      id TEXT PRIMARY KEY NOT NULL,
+      label TEXT NOT NULL,
+      type TEXT DEFAULT 'manual' NOT NULL,
+      status TEXT DEFAULT 'in_progress' NOT NULL,
+      file_path TEXT NOT NULL,
+      size_bytes INTEGER DEFAULT 0 NOT NULL,
+      db_size_bytes INTEGER DEFAULT 0 NOT NULL,
+      files_size_bytes INTEGER DEFAULT 0 NOT NULL,
+      file_count INTEGER DEFAULT 0 NOT NULL,
+      error TEXT,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_snapshots_type ON snapshots(type);
+    CREATE INDEX IF NOT EXISTS idx_snapshots_created_at ON snapshots(created_at);
+  `);
 }
 
 export function hasLegacyStagentTables(sqlite: Database.Database): boolean {

package/src/lib/db/index.ts

@@ -16,3 +16,12 @@ sqlite.pragma("foreign_keys = ON");
 bootstrapStagentDatabase(sqlite);
 
 export const db = drizzle(sqlite, { schema });
+export { sqlite };
+
+// Lazy seed: table templates (idempotent — checks before inserting)
+import("@/lib/data/seed-data/table-templates").then(({ seedTableTemplates }) => {
+  seedTableTemplates().catch(() => {
+    // Template seeding is non-critical — log and continue
+    console.warn("[db] table template seeding failed");
+  });
+});