stagent 0.9.5 → 0.10.0

package/src/lib/constants/settings.ts

@@ -2,8 +2,12 @@ export const SETTINGS_KEYS = {
   AUTH_METHOD: "auth.method",
   AUTH_API_KEY: "auth.apiKey",
   AUTH_API_KEY_SOURCE: "auth.apiKeySource",
+  OPENAI_AUTH_METHOD: "openai.authMethod",
   OPENAI_AUTH_API_KEY: "openai.authApiKey",
   OPENAI_AUTH_API_KEY_SOURCE: "openai.authApiKeySource",
+  OPENAI_AUTH_OAUTH_CONNECTED: "openai.oauthConnected",
+  OPENAI_AUTH_ACCOUNT: "openai.account",
+  OPENAI_AUTH_RATE_LIMITS: "openai.rateLimits",
   PERMISSIONS_ALLOW: "permissions.allow",
   BUDGET_POLICY: "usage.budgetPolicy",
   BUDGET_WARNING_STATE: "usage.budgetWarningState",
@@ -19,24 +23,10 @@ export const SETTINGS_KEYS = {
   ROUTING_PREFERENCE: "routing.preference",
   OLLAMA_BASE_URL: "ollama.baseUrl",
   OLLAMA_DEFAULT_MODEL: "ollama.defaultModel",
-  // License / PLG
-  LICENSE_TIER: "license.tier",
-  LICENSE_EMAIL: "license.email",
-  LICENSE_ACTIVATED_AT: "license.activatedAt",
-  LICENSE_EXPIRES_AT: "license.expiresAt",
-  LICENSE_GRACE_UNTIL: "license.graceUntil",
-  // Supabase cloud
-  SUPABASE_URL: "cloud.supabaseUrl",
-  SUPABASE_ANON_KEY: "cloud.supabaseAnonKey",
-  // Telemetry (opt-in)
-  TELEMETRY_ENABLED: "telemetry.enabled",
-  TELEMETRY_RUNTIME_ID: "telemetry.runtimeId",
-  TELEMETRY_BATCH: "telemetry.batch",
-  // Cloud sync
-  DEVICE_ID: "sync.deviceId",
-  LAST_SYNC_AT: "sync.lastSyncAt",
-  // Stripe
-  STRIPE_CUSTOMER_ID: "billing.stripeCustomerId",
+  // Schedule orchestration
+  SCHEDULE_MAX_CONCURRENT: "schedule.maxConcurrent",
+  SCHEDULE_MAX_RUN_DURATION_SEC: "schedule.maxRunDurationSec",
+  SCHEDULE_CHAT_PRESSURE_DELAY_SEC: "schedule.chatPressureDelaySec",
 } as const;
 
 export type RoutingPreference = "cost" | "latency" | "quality" | "manual";

package/src/lib/data/__tests__/clear.test.ts

@@ -2,10 +2,16 @@ import { describe, expect, it } from "vitest";
 import { readFileSync } from "fs";
 import { join } from "path";
 import * as schema from "@/lib/db/schema";
+import { db } from "@/lib/db";
+import { conversations, documents } from "@/lib/db/schema";
+import { clearAllData } from "../clear";
 
 /**
  * Safety-net test: every table exported from schema.ts must appear in clear.ts
- * (except `settings`, which is intentionally preserved across clears).
+ * (except tables in INTENTIONALLY_PRESERVED, which are kept across clears:
+ *  - settings: auth config
+ *  - snapshots: backups, not working data
+ *  - license: paid tier activation — clearing data must not silently downgrade)
  *
  * When you add a new table to schema.ts, this test will fail until you add a
  * corresponding db.delete() call to clear.ts in the correct FK-safe order.
@@ -13,7 +19,7 @@ import * as schema from "@/lib/db/schema";
 describe("clearAllData coverage", () => {
   const INTENTIONALLY_PRESERVED = ["settings", "snapshots"];
 
-  it("deletes every schema table (except settings)", () => {
+  it("deletes every schema table (except preserved ones)", () => {
     const clearSource = readFileSync(
       join(__dirname, "..", "clear.ts"),
       "utf-8"
@@ -40,3 +46,51 @@ describe("clearAllData coverage", () => {
     expect(missing, `Tables missing from clear.ts: ${missing.join(", ")}`).toEqual([]);
   });
 });
+
+/**
+ * FK ordering regression: `documents.conversation_id` references `conversations.id`.
+ * If clearAllData deletes `conversations` before `documents`, SQLite raises
+ * FOREIGN KEY constraint failed. This test seeds a document attached to a
+ * conversation and then calls clearAllData to ensure the ordering holds.
+ *
+ * Incident: the stagent-growth domain clone (2026-04-07) hit this because its
+ * seeded data included chat-attached documents.
+ */
+describe("clearAllData FK ordering", () => {
+  it("clears a conversation that has an attached document without FK violation", () => {
+    const now = new Date();
+    const conversationId = "test-conv-fk-ordering";
+    const documentId = "test-doc-fk-ordering";
+
+    db.insert(conversations)
+      .values({
+        id: conversationId,
+        runtimeId: "test-runtime",
+        status: "active",
+        createdAt: now,
+        updatedAt: now,
+      })
+      .run();
+
+    db.insert(documents)
+      .values({
+        id: documentId,
+        filename: "fk-ordering-test.txt",
+        originalName: "fk-ordering-test.txt",
+        mimeType: "text/plain",
+        size: 10,
+        storagePath: "/tmp/fk-ordering-test.txt",
+        conversationId,
+        createdAt: now,
+        updatedAt: now,
+      })
+      .run();
+
+    expect(() => clearAllData()).not.toThrow();
+
+    const remainingConvs = db.select().from(conversations).all();
+    const remainingDocs = db.select().from(documents).all();
+    expect(remainingConvs).toHaveLength(0);
+    expect(remainingDocs).toHaveLength(0);
+  });
+});

package/src/lib/data/clear.ts

@@ -25,7 +25,6 @@ import {
   channelBindings,
   channelConfigs,
   agentMessages,
-  license,
   workflowDocumentInputs,
   scheduleDocumentInputs,
   projectDocumentDefaults,
@@ -43,6 +42,7 @@ import {
   workflowTableInputs,
   scheduleTableInputs,
   workflowExecutionStats,
+  scheduleFiringMetrics,
 } from "@/lib/db/schema";
 import { readdirSync, unlinkSync, mkdirSync } from "fs";
 import { join } from "path";
@@ -55,7 +55,9 @@ const screenshotsDir = join(dataDir, "screenshots");
 
 /**
  * Wipe all data tables (FK-safe order) and uploaded files.
- * Preserves the settings table (auth config).
+ * Preserves the settings table (auth config) and the license table
+ * (paid tier activation) — clearing operational data should never
+ * silently downgrade a paid instance back to community.
  */
 export function clearAllData() {
   const sampleProfilesDeleted = clearSampleProfiles();
@@ -68,7 +70,18 @@ export function clearAllData() {
   const envScansDeleted = db.delete(environmentScans).run().changes;
   const envTemplatesDeleted = db.delete(environmentTemplates).run().changes;
 
-  // Chat tables (messages before conversations — FK safety)
+  // Document junction tables — delete before documents (they reference documents).
+  // Also referenced by projects/workflows/schedules, deleted later.
+  const workflowDocInputsDeleted = db.delete(workflowDocumentInputs).run().changes;
+  const scheduleDocInputsDeleted = db.delete(scheduleDocumentInputs).run().changes;
+  const projectDocDefaultsDeleted = db.delete(projectDocumentDefaults).run().changes;
+  // Documents reference conversations (documents.conversation_id) — must delete
+  // before conversations to avoid FK violation when chat-attached documents exist.
+  const documentsDeleted = db.delete(documents).run().changes;
+
+  // Chat tables: channel_bindings + chat_messages + documents all reference
+  // conversations — delete them before conversations.
+  const channelBindingsDeleted = db.delete(channelBindings).run().changes;
   const chatMessagesDeleted = db.delete(chatMessages).run().changes;
   const conversationsDeleted = db.delete(conversations).run().changes;
 
@@ -76,15 +89,12 @@ export function clearAllData() {
   const bookmarksDeleted = db.delete(bookmarks).run().changes;
   const readingProgressDeleted = db.delete(readingProgress).run().changes;
 
-  // Channel bindings reference channel_configs + conversations — delete before both
-  const channelBindingsDeleted = db.delete(channelBindings).run().changes;
-
   // Agent messages reference tasks — delete before tasks
   const agentMessagesDeleted = db.delete(agentMessages).run().changes;
   const channelConfigsDeleted = db.delete(channelConfigs).run().changes;
 
-  // License table — no FK dependencies
-  const licenseDeleted = db.delete(license).run().changes;
+  // License table is intentionally preserved — clearing operational data
+  // should never downgrade a paid instance back to community tier.
 
   // Snapshots are intentionally preserved — they are backups, not working data
 
@@ -112,17 +122,12 @@ export function clearAllData() {
   const userTablesDeleted = db.delete(userTables).run().changes;
   const userTableTemplatesDeleted = db.delete(userTableTemplates).run().changes;
 
-  // Document junction tables — delete before documents, workflows, schedules, projects
-  const workflowDocInputsDeleted = db.delete(workflowDocumentInputs).run().changes;
-  const scheduleDocInputsDeleted = db.delete(scheduleDocumentInputs).run().changes;
-  const projectDocDefaultsDeleted = db.delete(projectDocumentDefaults).run().changes;
-
-  const documentsDeleted = db.delete(documents).run().changes;
   const agentMemoryDeleted = db.delete(agentMemory).run().changes;
   const learnedContextDeleted = db.delete(learnedContext).run().changes;
   const executionStatsDeleted = db.delete(workflowExecutionStats).run().changes;
   const tasksDeleted = db.delete(tasks).run().changes;
   const workflowsDeleted = db.delete(workflows).run().changes;
+  const scheduleFiringMetricsDeleted = db.delete(scheduleFiringMetrics).run().changes;
   const schedulesDeleted = db.delete(schedules).run().changes;
   const projectsDeleted = db.delete(projects).run().changes;
 
@@ -156,6 +161,7 @@ export function clearAllData() {
     projects: projectsDeleted,
     tasks: tasksDeleted,
     workflows: workflowsDeleted,
+    scheduleFiringMetrics: scheduleFiringMetricsDeleted,
     schedules: schedulesDeleted,
     usageLedger: usageLedgerDeleted,
     agentLogs: logsDeleted,
@@ -195,7 +201,6 @@ export function clearAllData() {
     scheduleTableInputs: scheduleTableInputsDeleted,
     files: filesDeleted,
     screenshots: screenshotsDeleted,
-    license: licenseDeleted,
     workflowExecutionStats: executionStatsDeleted,
   };
 }

package/src/lib/data/delete-project.ts

@@ -0,0 +1,171 @@
+/**
+ * FK-safe cascade delete for a project and all its children.
+ * Shared by the API DELETE route and the delete_project chat tool.
+ */
+
+import { db } from "@/lib/db";
+import {
+  projects,
+  tasks,
+  workflows,
+  documents,
+  schedules,
+  agentLogs,
+  notifications,
+  learnedContext,
+  usageLedger,
+  environmentSyncOps,
+  environmentCheckpoints,
+  environmentArtifacts,
+  environmentScans,
+  chatMessages,
+  conversations,
+  projectDocumentDefaults,
+  userTables,
+  userTableColumns,
+  userTableRows,
+  userTableViews,
+  userTableImports,
+  userTableRelationships,
+  tableDocumentInputs,
+  taskTableInputs,
+  workflowTableInputs,
+  scheduleTableInputs,
+  userTableTriggers,
+  userTableRowHistory,
+} from "@/lib/db/schema";
+import { eq, inArray } from "drizzle-orm";
+
+/**
+ * Delete a project and all FK-dependent children in safe order.
+ * Returns true if the project existed and was deleted, false if not found.
+ */
+export function deleteProjectCascade(projectId: string): boolean {
+  const existing = db
+    .select({ id: projects.id })
+    .from(projects)
+    .where(eq(projects.id, projectId))
+    .get();
+
+  if (!existing) return false;
+
+  // 1. Collect child IDs for nested FK chains
+  const taskIds = db
+    .select({ id: tasks.id })
+    .from(tasks)
+    .where(eq(tasks.projectId, projectId))
+    .all()
+    .map((r) => r.id);
+
+  const workflowIds = db
+    .select({ id: workflows.id })
+    .from(workflows)
+    .where(eq(workflows.projectId, projectId))
+    .all()
+    .map((r) => r.id);
+
+  const conversationIds = db
+    .select({ id: conversations.id })
+    .from(conversations)
+    .where(eq(conversations.projectId, projectId))
+    .all()
+    .map((r) => r.id);
+
+  const scanIds = db
+    .select({ id: environmentScans.id })
+    .from(environmentScans)
+    .where(eq(environmentScans.projectId, projectId))
+    .all()
+    .map((r) => r.id);
+
+  const checkpointIds = db
+    .select({ id: environmentCheckpoints.id })
+    .from(environmentCheckpoints)
+    .where(eq(environmentCheckpoints.projectId, projectId))
+    .all()
+    .map((r) => r.id);
+
+  // 2. Environment tables (deepest children first)
+  if (checkpointIds.length > 0) {
+    db.delete(environmentSyncOps)
+      .where(inArray(environmentSyncOps.checkpointId, checkpointIds))
+      .run();
+    db.delete(environmentCheckpoints)
+      .where(inArray(environmentCheckpoints.id, checkpointIds))
+      .run();
+  }
+  if (scanIds.length > 0) {
+    db.delete(environmentArtifacts)
+      .where(inArray(environmentArtifacts.scanId, scanIds))
+      .run();
+    db.delete(environmentScans)
+      .where(inArray(environmentScans.id, scanIds))
+      .run();
+  }
+
+  // 3. Chat tables (messages before conversations)
+  if (conversationIds.length > 0) {
+    db.delete(chatMessages)
+      .where(inArray(chatMessages.conversationId, conversationIds))
+      .run();
+    db.delete(conversations)
+      .where(inArray(conversations.id, conversationIds))
+      .run();
+  }
+
+  // 4. Usage ledger
+  db.delete(usageLedger).where(eq(usageLedger.projectId, projectId)).run();
+
+  // 5. Task children (logs, notifications, documents, learned context)
+  if (taskIds.length > 0) {
+    db.delete(agentLogs).where(inArray(agentLogs.taskId, taskIds)).run();
+    db.delete(notifications)
+      .where(inArray(notifications.taskId, taskIds))
+      .run();
+    db.delete(documents).where(inArray(documents.taskId, taskIds)).run();
+    db.delete(learnedContext)
+      .where(inArray(learnedContext.sourceTaskId, taskIds))
+      .run();
+  }
+
+  // 6. Junction tables
+  db.delete(projectDocumentDefaults).where(eq(projectDocumentDefaults.projectId, projectId)).run();
+
+  // 6b. User-defined tables — cascade-delete children before parent
+  const tableIds = db
+    .select({ id: userTables.id })
+    .from(userTables)
+    .where(eq(userTables.projectId, projectId))
+    .all()
+    .map((r) => r.id);
+
+  if (tableIds.length > 0) {
+    // Junction tables first
+    db.delete(tableDocumentInputs).where(inArray(tableDocumentInputs.tableId, tableIds)).run();
+    db.delete(taskTableInputs).where(inArray(taskTableInputs.tableId, tableIds)).run();
+    db.delete(workflowTableInputs).where(inArray(workflowTableInputs.tableId, tableIds)).run();
+    db.delete(scheduleTableInputs).where(inArray(scheduleTableInputs.tableId, tableIds)).run();
+    // Children
+    db.delete(userTableRowHistory).where(inArray(userTableRowHistory.tableId, tableIds)).run();
+    db.delete(userTableTriggers).where(inArray(userTableTriggers.tableId, tableIds)).run();
+    db.delete(userTableImports).where(inArray(userTableImports.tableId, tableIds)).run();
+    db.delete(userTableViews).where(inArray(userTableViews.tableId, tableIds)).run();
+    db.delete(userTableRelationships).where(inArray(userTableRelationships.fromTableId, tableIds)).run();
+    db.delete(userTableRows).where(inArray(userTableRows.tableId, tableIds)).run();
+    db.delete(userTableColumns).where(inArray(userTableColumns.tableId, tableIds)).run();
+    db.delete(userTables).where(inArray(userTables.id, tableIds)).run();
+  }
+
+  // 7. Direct project children
+  db.delete(documents).where(eq(documents.projectId, projectId)).run();
+  db.delete(tasks).where(eq(tasks.projectId, projectId)).run();
+  if (workflowIds.length > 0) {
+    db.delete(workflows).where(inArray(workflows.id, workflowIds)).run();
+  }
+  db.delete(schedules).where(eq(schedules.projectId, projectId)).run();
+
+  // 8. Finally delete the project
+  db.delete(projects).where(eq(projects.id, projectId)).run();
+
+  return true;
+}

package/src/lib/db/__tests__/bootstrap.test.ts

@@ -50,7 +50,7 @@ describe("database bootstrap recovery", () => {
     const migrationCount = migratedDb
       .prepare("SELECT COUNT(*) AS count FROM __drizzle_migrations")
       .get() as { count: number };
-    expect(migrationCount.count).toBe(9);
+    expect(migrationCount.count).toBe(12);
     migratedDb.close();
   });
 });

package/src/lib/db/bootstrap.ts

@@ -45,8 +45,8 @@ const STAGENT_TABLES = [
   "user_table_triggers",
   "user_table_row_history",
   "snapshots",
-  "license",
   "workflow_execution_stats",
+  "schedule_firing_metrics",
 ] as const;
 
 export function bootstrapStagentDatabase(sqlite: Database.Database): void {
@@ -91,6 +91,7 @@ export function bootstrapStagentDatabase(sqlite: Database.Database): void {
       status TEXT DEFAULT 'draft' NOT NULL,
       run_number INTEGER DEFAULT 0 NOT NULL,
       runtime_id TEXT,
+      resume_at INTEGER,
       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
@@ -192,6 +193,32 @@ export function bootstrapStagentDatabase(sqlite: Database.Database): void {
     CREATE INDEX IF NOT EXISTS idx_schedules_next_fire_at ON schedules(next_fire_at);
     CREATE INDEX IF NOT EXISTS idx_schedules_project_id ON schedules(project_id);
 
+    -- schedule_firing_metrics is placed here (between schedules indexes and
+    -- notifications indexes) to satisfy its foreign-key dependency on schedules.
+    -- Future tables with FK dependencies should follow the same "place after
+    -- parent table" discipline rather than batching all CREATE TABLE at the top.
+    CREATE TABLE IF NOT EXISTS schedule_firing_metrics (
+      id TEXT PRIMARY KEY NOT NULL,
+      schedule_id TEXT NOT NULL,
+      task_id TEXT,
+      fired_at INTEGER NOT NULL,
+      slot_claimed_at INTEGER,
+      completed_at INTEGER,
+      slot_wait_ms INTEGER,
+      duration_ms INTEGER,
+      turn_count INTEGER,
+      max_turns_at_firing INTEGER,
+      event_loop_lag_ms REAL,
+      peak_rss_mb INTEGER,
+      chat_streams_active INTEGER,
+      concurrent_schedules INTEGER,
+      failure_reason TEXT,
+      FOREIGN KEY (schedule_id) REFERENCES schedules(id) ON UPDATE NO ACTION ON DELETE NO ACTION,
+      FOREIGN KEY (task_id) REFERENCES tasks(id) ON UPDATE NO ACTION ON DELETE NO ACTION
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_sfm_schedule_time ON schedule_firing_metrics(schedule_id, fired_at);
+
     CREATE INDEX IF NOT EXISTS idx_notifications_task_id ON notifications(task_id);
     CREATE INDEX IF NOT EXISTS idx_notifications_read ON notifications(read);
     CREATE INDEX IF NOT EXISTS idx_documents_task_id ON documents(task_id);
@@ -260,6 +287,7 @@ export function bootstrapStagentDatabase(sqlite: Database.Database): void {
 
     CREATE INDEX IF NOT EXISTS idx_views_surface ON views(surface);
     CREATE INDEX IF NOT EXISTS idx_views_surface_default ON views(surface, is_default);
+
   `);
 
   const addColumnIfMissing = (ddl: string) => {
@@ -305,6 +333,10 @@ export function bootstrapStagentDatabase(sqlite: Database.Database): void {
   addColumnIfMissing(`ALTER TABLE documents ADD COLUMN source TEXT DEFAULT 'upload';`);
   addColumnIfMissing(`ALTER TABLE documents ADD COLUMN conversation_id TEXT REFERENCES conversations(id);`);
   addColumnIfMissing(`ALTER TABLE documents ADD COLUMN message_id TEXT;`);
+  // Workflow step delays — resume_at for schedule-based delay resumption.
+  // The partial index on resume_at is created by migration 0024 for fresh DBs;
+  // existing DBs that don't run migrations will do a small table scan instead.
+  addColumnIfMissing(`ALTER TABLE workflows ADD COLUMN resume_at INTEGER;`);
   sqlite.exec(`CREATE INDEX IF NOT EXISTS idx_documents_source ON documents(source);`);
   sqlite.exec(`CREATE INDEX IF NOT EXISTS idx_documents_conversation_id ON documents(conversation_id);`);
 
@@ -552,6 +584,18 @@ export function bootstrapStagentDatabase(sqlite: Database.Database): void {
   addColumnIfMissing(`ALTER TABLE schedules ADD COLUMN last_failure_reason TEXT;`);
   addColumnIfMissing(`ALTER TABLE channel_configs ADD COLUMN direction TEXT DEFAULT 'outbound' NOT NULL;`);
 
+  // ── Schedule Orchestration columns ───────────────────────────────────────
+  addColumnIfMissing(`ALTER TABLE tasks ADD COLUMN slot_claimed_at INTEGER;`);
+  addColumnIfMissing(`ALTER TABLE tasks ADD COLUMN lease_expires_at INTEGER;`);
+  addColumnIfMissing(`ALTER TABLE tasks ADD COLUMN failure_reason TEXT;`);
+  addColumnIfMissing(`ALTER TABLE tasks ADD COLUMN max_turns INTEGER;`);
+  addColumnIfMissing(`ALTER TABLE schedules ADD COLUMN max_turns INTEGER;`);
+  addColumnIfMissing(`ALTER TABLE schedules ADD COLUMN max_turns_set_at INTEGER;`);
+  addColumnIfMissing(`ALTER TABLE schedules ADD COLUMN max_run_duration_sec INTEGER;`);
+  addColumnIfMissing(`ALTER TABLE schedules ADD COLUMN turn_budget_breach_streak INTEGER DEFAULT 0 NOT NULL;`);
+  // Create the composite index for lease-reaper queries (idempotent)
+  sqlite.exec(`CREATE INDEX IF NOT EXISTS idx_tasks_running_scheduled ON tasks(status, source_type, lease_expires_at);`);
+
   // ── Bidirectional Channel Chat ──────────────────────────────────────────
   sqlite.exec(`
     CREATE TABLE IF NOT EXISTS channel_bindings (
@@ -856,21 +900,6 @@ export function bootstrapStagentDatabase(sqlite: Database.Database): void {
     CREATE INDEX IF NOT EXISTS idx_snapshots_type ON snapshots(type);
     CREATE INDEX IF NOT EXISTS idx_snapshots_created_at ON snapshots(created_at);
 
-    CREATE TABLE IF NOT EXISTS license (
-      id TEXT PRIMARY KEY NOT NULL,
-      supabase_user_id TEXT,
-      tier TEXT DEFAULT 'community' NOT NULL,
-      status TEXT DEFAULT 'inactive' NOT NULL,
-      email TEXT,
-      activated_at INTEGER,
-      expires_at INTEGER,
-      last_validated_at INTEGER,
-      grace_period_expires_at INTEGER,
-      encrypted_token TEXT,
-      created_at INTEGER NOT NULL,
-      updated_at INTEGER NOT NULL
-    );
-
     CREATE TABLE IF NOT EXISTS workflow_execution_stats (
       id TEXT PRIMARY KEY,
       pattern TEXT NOT NULL,

package/src/lib/db/index.ts

@@ -13,6 +13,11 @@ const dbPath = join(dataDir, "stagent.db");
 const sqlite = new Database(dbPath);
 sqlite.pragma("journal_mode = WAL");
 sqlite.pragma("foreign_keys = ON");
+
+// Bootstrap creates tables with IF NOT EXISTS + adds columns.
+// Drizzle migrations (DROP TABLE, CREATE INDEX, etc.) run separately
+// at server startup in instrumentation-node.ts to avoid SQLITE_BUSY
+// conflicts during next build.
 bootstrapStagentDatabase(sqlite);
 
 export const db = drizzle(sqlite, { schema });

package/src/lib/db/migrations/0009_add_app_instances.sql

@@ -0,0 +1,25 @@
+-- Historical migration: app_instances table (removed in 0025).
+-- Kept for Drizzle journal compatibility.
+CREATE TABLE IF NOT EXISTS app_instances (
+  id TEXT PRIMARY KEY NOT NULL,
+  app_id TEXT NOT NULL,
+  name TEXT NOT NULL,
+  version TEXT NOT NULL,
+  project_id TEXT,
+  manifest_json TEXT NOT NULL,
+  ui_schema_json TEXT NOT NULL,
+  resource_map_json TEXT DEFAULT '{}' NOT NULL,
+  status TEXT DEFAULT 'installing' NOT NULL,
+  source_type TEXT DEFAULT 'builtin' NOT NULL,
+  bootstrap_error TEXT,
+  installed_at INTEGER NOT NULL,
+  bootstrapped_at INTEGER,
+  updated_at INTEGER NOT NULL,
+  FOREIGN KEY (project_id) REFERENCES projects(id) ON UPDATE NO ACTION ON DELETE NO ACTION
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX IF NOT EXISTS idx_app_instances_app_id ON app_instances(app_id);
+--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS idx_app_instances_project_id ON app_instances(project_id);
+--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS idx_app_instances_status ON app_instances(status);

package/src/lib/db/migrations/0024_add_workflow_resume_at.sql

@@ -0,0 +1,10 @@
+-- Workflow Step Delays — Track A.2
+-- Adds resume_at timestamp column to workflows for schedule-based delay resumption.
+-- When a workflow pauses at a delay step, it writes resume_at = now + delayDuration.
+-- The scheduler tick queries WHERE status='paused' AND resume_at <= now() to find due workflows.
+-- Partial index keeps the query cheap: only paused workflows with a pending resume are indexed.
+
+ALTER TABLE workflows ADD COLUMN resume_at INTEGER;
+CREATE INDEX IF NOT EXISTS idx_workflows_resume_at
+  ON workflows(resume_at)
+  WHERE resume_at IS NOT NULL;

package/src/lib/db/migrations/0025_drop_app_instances.sql

@@ -0,0 +1,3 @@
+-- Remove the deprecated app_instances table.
+-- IF EXISTS guards against fresh databases that never had this table.
+DROP TABLE IF EXISTS app_instances;

package/src/lib/db/migrations/0026_drop_license.sql

@@ -0,0 +1,3 @@
+-- Remove the license table (Community Edition simplification).
+-- IF EXISTS guards against fresh databases that never had this table.
+DROP TABLE IF EXISTS license;

package/src/lib/db/migrations/meta/_journal.json

@@ -64,6 +64,27 @@
       "when": 1773705600000,
       "tag": "0008_add_document_version",
       "breakpoints": true
+    },
+    {
+      "idx": 9,
+      "version": "7",
+      "when": 1775779200000,
+      "tag": "0009_add_app_instances",
+      "breakpoints": true
+    },
+    {
+      "idx": 10,
+      "version": "7",
+      "when": 1776470400000,
+      "tag": "0025_drop_app_instances",
+      "breakpoints": true
+    },
+    {
+      "idx": 11,
+      "version": "7",
+      "when": 1776556800000,
+      "tag": "0026_drop_license",
+      "breakpoints": true
     }
   ]
 }