stagent 0.9.6 → 0.11.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,8 @@ 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) — clearing operational
+ * data should never silently reset user auth preferences.
  */
 export function clearAllData() {
   const sampleProfilesDeleted = clearSampleProfiles();
@@ -68,7 +69,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,16 +88,10 @@ 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;
-
   // Snapshots are intentionally preserved — they are backups, not working data
 
   const repoImportsDeleted = db.delete(repoImports).run().changes;
@@ -112,17 +118,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 +157,7 @@ export function clearAllData() {
     projects: projectsDeleted,
     tasks: tasksDeleted,
     workflows: workflowsDeleted,
+    scheduleFiringMetrics: scheduleFiringMetricsDeleted,
     schedules: schedulesDeleted,
     usageLedger: usageLedgerDeleted,
     agentLogs: logsDeleted,
@@ -195,7 +197,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 {
@@ -70,6 +70,9 @@ export function bootstrapStagentDatabase(sqlite: Database.Database): void {
       status TEXT DEFAULT 'planned' NOT NULL,
       assigned_agent TEXT,
       agent_profile TEXT,
+      effective_runtime_id TEXT,
+      effective_model_id TEXT,
+      runtime_fallback_reason TEXT,
       priority INTEGER DEFAULT 2 NOT NULL,
       result TEXT,
       session_id TEXT,
@@ -91,6 +94,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 +196,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 +290,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) => {
@@ -275,6 +306,9 @@ export function bootstrapStagentDatabase(sqlite: Database.Database): void {
 
   addColumnIfMissing(`ALTER TABLE tasks ADD COLUMN agent_profile TEXT;`);
   sqlite.exec(`CREATE INDEX IF NOT EXISTS idx_tasks_agent_profile ON tasks(agent_profile);`);
+  addColumnIfMissing(`ALTER TABLE tasks ADD COLUMN effective_runtime_id TEXT;`);
+  addColumnIfMissing(`ALTER TABLE tasks ADD COLUMN effective_model_id TEXT;`);
+  addColumnIfMissing(`ALTER TABLE tasks ADD COLUMN runtime_fallback_reason TEXT;`);
 
   addColumnIfMissing(`ALTER TABLE tasks ADD COLUMN workflow_id TEXT REFERENCES workflows(id);`);
   sqlite.exec(`CREATE INDEX IF NOT EXISTS idx_tasks_workflow_id ON tasks(workflow_id);`);
@@ -305,6 +339,19 @@ 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;`);
+  // chat-ollama-native-skills: conversation-scoped active skill binding.
+  // Ollama can't use the SDK's native skill support, so we inject the
+  // selected skill's SKILL.md into Tier 0 of the system prompt on every
+  // turn while this column is set. Same machinery is usable from Claude
+  // and Codex as a programmatic skill-activation path.
+  addColumnIfMissing(`ALTER TABLE conversations ADD COLUMN active_skill_id TEXT;`);
+  // chat-skill-composition v1: array of additionally-activated skill IDs
+  // beyond the legacy active_skill_id. Default empty JSON array.
+  addColumnIfMissing(`ALTER TABLE conversations ADD COLUMN active_skill_ids TEXT DEFAULT '[]';`);
+  // 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);`);
 
@@ -423,6 +470,8 @@ export function bootstrapStagentDatabase(sqlite: Database.Database): void {
       status TEXT DEFAULT 'active' NOT NULL,
       session_id TEXT,
       context_scope TEXT,
+      active_skill_id TEXT,
+      active_skill_ids TEXT DEFAULT '[]',
       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
@@ -552,6 +601,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 +917,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
     }
   ]
 }