@axiom-lattice/pg-stores 1.0.21 → 1.0.23

package/dist/index.mjs

@@ -175,9 +175,111 @@ var createThreadsTable = {
   }
 };
 
+// src/migrations/thread_tenant_migration.ts
+var addThreadTenantId = {
+  version: 15,
+  name: "add_thread_tenant_id",
+  up: async (client) => {
+    await client.query(`
+      ALTER TABLE lattice_threads
+      ADD COLUMN IF NOT EXISTS tenant_id VARCHAR(255) DEFAULT 'default'
+    `);
+    await client.query(`
+      UPDATE lattice_threads 
+      SET tenant_id = 'default' 
+      WHERE tenant_id IS NULL
+    `);
+    await client.query(`
+      ALTER TABLE lattice_threads
+      ALTER COLUMN tenant_id SET NOT NULL
+    `);
+    await client.query(`
+      ALTER TABLE lattice_threads
+      ALTER COLUMN tenant_id DROP DEFAULT
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_threads_tenant_id 
+      ON lattice_threads(tenant_id)
+    `);
+  },
+  down: async (client) => {
+    await client.query(
+      "DROP INDEX IF EXISTS idx_lattice_threads_tenant_id"
+    );
+    await client.query(
+      "ALTER TABLE lattice_threads DROP COLUMN IF EXISTS tenant_id"
+    );
+  }
+};
+
+// src/migrations/thread_pk_migration.ts
+var changeThreadPrimaryKey = {
+  version: 19,
+  name: "change_thread_primary_key",
+  up: async (client) => {
+    const tableExists = await client.query(`
+      SELECT EXISTS (
+        SELECT FROM information_schema.tables 
+        WHERE table_name = 'lattice_threads'
+      )
+    `);
+    if (!tableExists.rows[0].exists) {
+      return;
+    }
+    const pkResult = await client.query(`
+      SELECT a.attname as column_name
+      FROM pg_index i
+      JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey)
+      WHERE i.indrelid = 'lattice_threads'::regclass
+      AND i.indisprimary
+    `);
+    const pkColumns = pkResult.rows.map((row) => row.column_name);
+    if (pkColumns.includes("tenant_id") && pkColumns.includes("id") && pkColumns.length === 2) {
+      console.log("Primary key already correct (id, tenant_id)");
+      return;
+    }
+    if (pkColumns.includes("id") && pkColumns.includes("assistant_id")) {
+      console.log("Changing primary key from (id, assistant_id) to (id, tenant_id)");
+      const tenantIdExists = await client.query(`
+        SELECT EXISTS (
+          SELECT FROM information_schema.columns 
+          WHERE table_name = 'lattice_threads' 
+          AND column_name = 'tenant_id'
+        )
+      `);
+      if (!tenantIdExists.rows[0].exists) {
+        await client.query(`
+          ALTER TABLE lattice_threads
+          ADD COLUMN tenant_id VARCHAR(255) DEFAULT 'default'
+        `);
+      }
+      await client.query(`
+        UPDATE lattice_threads 
+        SET tenant_id = 'default' 
+        WHERE tenant_id IS NULL
+      `);
+      await client.query(`
+        ALTER TABLE lattice_threads
+        ALTER COLUMN tenant_id SET NOT NULL
+      `);
+      await client.query(`
+        ALTER TABLE lattice_threads 
+        DROP CONSTRAINT IF EXISTS lattice_threads_pkey
+      `);
+      await client.query(`
+        ALTER TABLE lattice_threads 
+        ADD PRIMARY KEY (id, tenant_id)
+      `);
+      console.log("Primary key changed successfully to (id, tenant_id)");
+    }
+  },
+  down: async (client) => {
+    console.warn("Down migration for changeThreadPrimaryKey is not supported");
+  }
+};
+
 // src/stores/PostgreSQLThreadStore.ts
 var PostgreSQLThreadStore = class {
-  // Promise-based lock to prevent concurrent initialization
   constructor(options) {
     this.initialized = false;
     this.ownsPool = true;
@@ -189,6 +291,8 @@ var PostgreSQLThreadStore = class {
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createThreadsTable);
+    this.migrationManager.register(addThreadTenantId);
+    this.migrationManager.register(changeThreadPrimaryKey);
     if (options.autoMigrate !== false) {
       this.initialize().catch((error) => {
         console.error("Failed to initialize PostgreSQLThreadStore:", error);
@@ -227,33 +331,33 @@ var PostgreSQLThreadStore = class {
     return this.initPromise;
   }
   /**
-   * Get all threads for a specific assistant
+   * Get all threads for a specific tenant and assistant
    */
-  async getThreadsByAssistantId(assistantId) {
+  async getThreadsByAssistantId(tenantId, assistantId) {
     await this.ensureInitialized();
     const result = await this.pool.query(
       `
-      SELECT id, assistant_id, metadata, created_at, updated_at
+      SELECT id, tenant_id, assistant_id, metadata, created_at, updated_at
       FROM lattice_threads
-      WHERE assistant_id = $1
+      WHERE tenant_id = $1 AND assistant_id = $2
       ORDER BY created_at DESC
     `,
-      [assistantId]
+      [tenantId, assistantId]
     );
     return result.rows.map(this.mapRowToThread);
   }
   /**
-   * Get a thread by ID for a specific assistant
+   * Get a thread by ID for a specific tenant
    */
-  async getThreadById(assistantId, threadId) {
+  async getThreadById(tenantId, threadId) {
     await this.ensureInitialized();
     const result = await this.pool.query(
       `
-      SELECT id, assistant_id, metadata, created_at, updated_at
+      SELECT id, tenant_id, assistant_id, metadata, created_at, updated_at
       FROM lattice_threads
-      WHERE id = $1 AND assistant_id = $2
+      WHERE tenant_id = $1 AND id = $2
     `,
-      [threadId, assistantId]
+      [tenantId, threadId]
     );
     if (result.rows.length === 0) {
       return void 0;
@@ -261,24 +365,26 @@ var PostgreSQLThreadStore = class {
     return this.mapRowToThread(result.rows[0]);
   }
   /**
-   * Create a new thread for an assistant
+   * Create a new thread for a tenant and assistant
    */
-  async createThread(assistantId, threadId, data) {
+  async createThread(tenantId, assistantId, threadId, data) {
     await this.ensureInitialized();
     const now = /* @__PURE__ */ new Date();
     const metadata = data.metadata || {};
     await this.pool.query(
       `
-      INSERT INTO lattice_threads (id, assistant_id, metadata, created_at, updated_at)
-      VALUES ($1, $2, $3, $4, $5)
-      ON CONFLICT (id, assistant_id) DO UPDATE SET
+      INSERT INTO lattice_threads (id, tenant_id, assistant_id, metadata, created_at, updated_at)
+      VALUES ($1, $2, $3, $4, $5, $6)
+      ON CONFLICT (id, tenant_id) DO UPDATE SET
+        assistant_id = EXCLUDED.assistant_id,
         metadata = EXCLUDED.metadata,
         updated_at = EXCLUDED.updated_at
     `,
-      [threadId, assistantId, JSON.stringify(metadata), now, now]
+      [threadId, tenantId, assistantId, JSON.stringify(metadata), now, now]
     );
     return {
       id: threadId,
+      tenantId,
       assistantId,
       metadata,
       createdAt: now,
@@ -288,9 +394,9 @@ var PostgreSQLThreadStore = class {
   /**
    * Update an existing thread
    */
-  async updateThread(assistantId, threadId, updates) {
+  async updateThread(tenantId, threadId, updates) {
     await this.ensureInitialized();
-    const existing = await this.getThreadById(assistantId, threadId);
+    const existing = await this.getThreadById(tenantId, threadId);
     if (!existing) {
       return null;
     }
@@ -303,9 +409,9 @@ var PostgreSQLThreadStore = class {
       `
       UPDATE lattice_threads
       SET metadata = $1, updated_at = $2
-      WHERE id = $3 AND assistant_id = $4
+      WHERE tenant_id = $3 AND id = $4
     `,
-      [JSON.stringify(updatedMetadata), now, threadId, assistantId]
+      [JSON.stringify(updatedMetadata), now, tenantId, threadId]
     );
     return {
       ...existing,
@@ -316,29 +422,29 @@ var PostgreSQLThreadStore = class {
   /**
    * Delete a thread by ID
    */
-  async deleteThread(assistantId, threadId) {
+  async deleteThread(tenantId, threadId) {
     await this.ensureInitialized();
     const result = await this.pool.query(
       `
       DELETE FROM lattice_threads
-      WHERE id = $1 AND assistant_id = $2
+      WHERE tenant_id = $1 AND id = $2
     `,
-      [threadId, assistantId]
+      [tenantId, threadId]
     );
     return result.rowCount !== null && result.rowCount > 0;
   }
   /**
    * Check if thread exists
    */
-  async hasThread(assistantId, threadId) {
+  async hasThread(tenantId, threadId) {
     await this.ensureInitialized();
     const result = await this.pool.query(
       `
       SELECT 1 FROM lattice_threads
-      WHERE id = $1 AND assistant_id = $2
+      WHERE tenant_id = $1 AND id = $2
       LIMIT 1
     `,
-      [threadId, assistantId]
+      [tenantId, threadId]
     );
     return result.rows.length > 0;
   }
@@ -356,6 +462,7 @@ var PostgreSQLThreadStore = class {
   mapRowToThread(row) {
     return {
       id: row.id,
+      tenantId: row.tenant_id,
       assistantId: row.assistant_id,
       metadata: typeof row.metadata === "string" ? JSON.parse(row.metadata) : row.metadata || {},
       createdAt: row.created_at,
@@ -374,12 +481,14 @@ var createAssistantsTable = {
   up: async (client) => {
     await client.query(`
       CREATE TABLE IF NOT EXISTS lattice_assistants (
-        id VARCHAR(255) PRIMARY KEY,
+        id VARCHAR(255) NOT NULL,
+        tenant_id VARCHAR(255) NOT NULL DEFAULT 'default',
         name VARCHAR(255) NOT NULL,
         description TEXT,
         graph_definition JSONB NOT NULL,
         created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-        updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+        updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        PRIMARY KEY (tenant_id, id)
       )
     `);
     await client.query(`
@@ -400,11 +509,95 @@ var createAssistantsTable = {
   }
 };
 
+// src/migrations/assistant_tenant_migration.ts
+var addAssistantTenantId = {
+  version: 14,
+  name: "add_assistant_tenant_id",
+  up: async (client) => {
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_assistants_tenant_id 
+      ON lattice_assistants(tenant_id)
+    `);
+  },
+  down: async (client) => {
+    await client.query(
+      "DROP INDEX IF EXISTS idx_lattice_assistants_tenant_id"
+    );
+  }
+};
+
+// src/migrations/assistant_pk_migration.ts
+var changeAssistantPrimaryKey = {
+  version: 15,
+  name: "change_assistant_primary_key",
+  up: async (client) => {
+    const tableExists = await client.query(`
+      SELECT EXISTS (
+        SELECT FROM information_schema.tables 
+        WHERE table_name = 'lattice_assistants'
+      )
+    `);
+    if (!tableExists.rows[0].exists) {
+      return;
+    }
+    const pkResult = await client.query(`
+      SELECT a.attname as column_name
+      FROM pg_index i
+      JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey)
+      WHERE i.indrelid = 'lattice_assistants'::regclass
+      AND i.indisprimary
+    `);
+    const pkColumns = pkResult.rows.map((row) => row.column_name);
+    if (pkColumns.includes("tenant_id") && pkColumns.includes("id")) {
+      console.log("Primary key already correct (tenant_id, id)");
+      return;
+    }
+    if (pkColumns.length === 1 && pkColumns[0] === "id") {
+      console.log("Changing primary key from (id) to (tenant_id, id)");
+      const tenantIdExists = await client.query(`
+        SELECT EXISTS (
+          SELECT FROM information_schema.columns 
+          WHERE table_name = 'lattice_assistants' 
+          AND column_name = 'tenant_id'
+        )
+      `);
+      if (!tenantIdExists.rows[0].exists) {
+        await client.query(`
+          ALTER TABLE lattice_assistants
+          ADD COLUMN tenant_id VARCHAR(255) DEFAULT 'default'
+        `);
+      }
+      await client.query(`
+        UPDATE lattice_assistants 
+        SET tenant_id = 'default' 
+        WHERE tenant_id IS NULL
+      `);
+      await client.query(`
+        ALTER TABLE lattice_assistants
+        ALTER COLUMN tenant_id SET NOT NULL
+      `);
+      await client.query(`
+        ALTER TABLE lattice_assistants 
+        DROP CONSTRAINT IF EXISTS lattice_assistants_pkey
+      `);
+      await client.query(`
+        ALTER TABLE lattice_assistants 
+        ADD PRIMARY KEY (tenant_id, id)
+      `);
+      console.log("Primary key changed successfully to (tenant_id, id)");
+    }
+  },
+  down: async (client) => {
+    console.warn("Down migration for changeAssistantPrimaryKey is not supported");
+  }
+};
+
 // src/stores/PostgreSQLAssistantStore.ts
 var PostgreSQLAssistantStore = class {
   constructor(options) {
     this.initialized = false;
     this.ownsPool = true;
+    this.initPromise = null;
     if (typeof options.poolConfig === "string") {
       this.pool = new Pool2({ connectionString: options.poolConfig });
     } else {
@@ -412,6 +605,8 @@ var PostgreSQLAssistantStore = class {
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createAssistantsTable);
+    this.migrationManager.register(addAssistantTenantId);
+    this.migrationManager.register(changeAssistantPrimaryKey);
     if (options.autoMigrate !== false) {
       this.initialize().catch((error) => {
         console.error("Failed to initialize PostgreSQLAssistantStore:", error);
@@ -421,40 +616,53 @@ var PostgreSQLAssistantStore = class {
   }
   /**
    * Initialize the store and run migrations
+   * Uses a promise-based lock to prevent concurrent initialization
    */
   async initialize() {
     if (this.initialized) {
       return;
     }
-    await this.migrationManager.migrate();
-    this.initialized = true;
+    if (this.initPromise) {
+      return this.initPromise;
+    }
+    this.initPromise = (async () => {
+      try {
+        await this.migrationManager.migrate();
+        this.initialized = true;
+      } finally {
+        this.initPromise = null;
+      }
+    })();
+    return this.initPromise;
   }
   /**
-   * Get all assistants
+   * Get all assistants for a tenant
    */
-  async getAllAssistants() {
+  async getAllAssistants(tenantId) {
     await this.ensureInitialized();
     const result = await this.pool.query(
       `
-      SELECT id, name, description, graph_definition, created_at, updated_at
+      SELECT id, tenant_id, name, description, graph_definition, created_at, updated_at
       FROM lattice_assistants
+      WHERE tenant_id = $1
       ORDER BY created_at DESC
-    `
+    `,
+      [tenantId]
     );
     return result.rows.map(this.mapRowToAssistant);
   }
   /**
    * Get assistant by ID
    */
-  async getAssistantById(id) {
+  async getAssistantById(tenantId, id) {
     await this.ensureInitialized();
     const result = await this.pool.query(
       `
-      SELECT id, name, description, graph_definition, created_at, updated_at
+      SELECT id, tenant_id, name, description, graph_definition, created_at, updated_at
       FROM lattice_assistants
-      WHERE id = $1
+      WHERE tenant_id = $1 AND id = $2
     `,
-      [id]
+      [tenantId, id]
     );
     if (result.rows.length === 0) {
       return null;
@@ -464,14 +672,15 @@ var PostgreSQLAssistantStore = class {
   /**
    * Create a new assistant
    */
-  async createAssistant(id, data) {
+  async createAssistant(tenantId, id, data) {
     await this.ensureInitialized();
     const now = /* @__PURE__ */ new Date();
     await this.pool.query(
       `
-      INSERT INTO lattice_assistants (id, name, description, graph_definition, created_at, updated_at)
-      VALUES ($1, $2, $3, $4, $5, $6)
+      INSERT INTO lattice_assistants (id, tenant_id, name, description, graph_definition, created_at, updated_at)
+      VALUES ($1, $2, $3, $4, $5, $6, $7)
       ON CONFLICT (id) DO UPDATE SET
+        tenant_id = EXCLUDED.tenant_id,
         name = EXCLUDED.name,
         description = EXCLUDED.description,
         graph_definition = EXCLUDED.graph_definition,
@@ -479,6 +688,7 @@ var PostgreSQLAssistantStore = class {
     `,
       [
         id,
+        tenantId,
         data.name,
         data.description || null,
         JSON.stringify(data.graphDefinition),
@@ -488,6 +698,7 @@ var PostgreSQLAssistantStore = class {
     );
     return {
       id,
+      tenantId,
       name: data.name,
       description: data.description,
       graphDefinition: data.graphDefinition,
@@ -498,9 +709,9 @@ var PostgreSQLAssistantStore = class {
   /**
    * Update an existing assistant
    */
-  async updateAssistant(id, updates) {
+  async updateAssistant(tenantId, id, updates) {
     await this.ensureInitialized();
-    const existing = await this.getAssistantById(id);
+    const existing = await this.getAssistantById(tenantId, id);
     if (!existing) {
       return null;
     }
@@ -524,43 +735,44 @@ var PostgreSQLAssistantStore = class {
     }
     updateFields.push(`updated_at = $${paramIndex++}`);
     updateValues.push(/* @__PURE__ */ new Date());
+    updateValues.push(tenantId);
     updateValues.push(id);
     await this.pool.query(
       `
       UPDATE lattice_assistants
       SET ${updateFields.join(", ")}
-      WHERE id = $${paramIndex}
+      WHERE tenant_id = $${paramIndex++} AND id = $${paramIndex}
     `,
       updateValues
     );
-    return await this.getAssistantById(id);
+    return await this.getAssistantById(tenantId, id);
   }
   /**
    * Delete an assistant by ID
    */
-  async deleteAssistant(id) {
+  async deleteAssistant(tenantId, id) {
     await this.ensureInitialized();
     const result = await this.pool.query(
       `
       DELETE FROM lattice_assistants
-      WHERE id = $1
+      WHERE tenant_id = $1 AND id = $2
     `,
-      [id]
+      [tenantId, id]
     );
     return result.rowCount !== null && result.rowCount > 0;
   }
   /**
    * Check if assistant exists
    */
-  async hasAssistant(id) {
+  async hasAssistant(tenantId, id) {
     await this.ensureInitialized();
     const result = await this.pool.query(
       `
       SELECT 1 FROM lattice_assistants
-      WHERE id = $1
+      WHERE tenant_id = $1 AND id = $2
       LIMIT 1
     `,
-      [id]
+      [tenantId, id]
     );
     return result.rows.length > 0;
   }
@@ -587,6 +799,7 @@ var PostgreSQLAssistantStore = class {
   mapRowToAssistant(row) {
     return {
       id: row.id,
+      tenantId: row.tenant_id,
       name: row.name,
       description: row.description || void 0,
       graphDefinition: typeof row.graph_definition === "string" ? JSON.parse(row.graph_definition) : row.graph_definition,
@@ -709,6 +922,59 @@ var createScheduledTasksTable = {
   }
 };
 
+// src/migrations/schedule_tenant_migration.ts
+var addScheduleTenantId = {
+  version: 18,
+  name: "add_schedule_tenant_id",
+  up: async (client) => {
+    await client.query(`
+      ALTER TABLE lattice_scheduled_tasks
+      ADD COLUMN IF NOT EXISTS tenant_id VARCHAR(255) DEFAULT 'default'
+    `);
+    await client.query(`
+      UPDATE lattice_scheduled_tasks 
+      SET tenant_id = 'default' 
+      WHERE tenant_id IS NULL
+    `);
+    await client.query(`
+      ALTER TABLE lattice_scheduled_tasks
+      ALTER COLUMN tenant_id SET NOT NULL
+    `);
+    await client.query(`
+      ALTER TABLE lattice_scheduled_tasks
+      ALTER COLUMN tenant_id DROP DEFAULT
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_scheduled_tasks_tenant_id 
+      ON lattice_scheduled_tasks(tenant_id)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_scheduled_tasks_tenant_assistant 
+      ON lattice_scheduled_tasks(tenant_id, assistant_id)
+      WHERE assistant_id IS NOT NULL
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_scheduled_tasks_tenant_thread 
+      ON lattice_scheduled_tasks(tenant_id, thread_id)
+      WHERE thread_id IS NOT NULL
+    `);
+  },
+  down: async (client) => {
+    await client.query(
+      "DROP INDEX IF EXISTS idx_scheduled_tasks_tenant_thread"
+    );
+    await client.query(
+      "DROP INDEX IF EXISTS idx_scheduled_tasks_tenant_assistant"
+    );
+    await client.query(
+      "DROP INDEX IF EXISTS idx_scheduled_tasks_tenant_id"
+    );
+    await client.query(
+      "ALTER TABLE lattice_scheduled_tasks DROP COLUMN IF EXISTS tenant_id"
+    );
+  }
+};
+
 // src/stores/PostgreSQLScheduleStorage.ts
 var PostgreSQLScheduleStorage = class {
   constructor(options) {
@@ -720,6 +986,7 @@ var PostgreSQLScheduleStorage = class {
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createScheduledTasksTable);
+    this.migrationManager.register(addScheduleTenantId);
     if (options.autoMigrate !== false) {
       this.initialize().catch((error) => {
         console.error("Failed to initialize PostgreSQLScheduleStorage:", error);
@@ -1016,6 +1283,10 @@ var PostgreSQLScheduleStorage = class {
     const whereClauses = [];
     const values = [];
     let paramIndex = 1;
+    if (filters?.tenantId !== void 0) {
+      whereClauses.push(`tenant_id = $${paramIndex++}`);
+      values.push(filters.tenantId);
+    }
     if (filters?.status !== void 0) {
       whereClauses.push(`status = $${paramIndex++}`);
       values.push(filters.status);
@@ -1060,6 +1331,10 @@ var PostgreSQLScheduleStorage = class {
     const whereClauses = [];
     const values = [];
     let paramIndex = 1;
+    if (filters?.tenantId !== void 0) {
+      whereClauses.push(`tenant_id = $${paramIndex++}`);
+      values.push(filters.tenantId);
+    }
     if (filters?.status !== void 0) {
       whereClauses.push(`status = $${paramIndex++}`);
       values.push(filters.status);
@@ -1192,11 +1467,115 @@ var createSkillsTable = {
   }
 };
 
+// src/migrations/skill_tenant_migration.ts
+var addSkillTenantId = {
+  version: 16,
+  name: "add_skill_tenant_id",
+  up: async (client) => {
+    await client.query(`
+      ALTER TABLE lattice_skills
+      ADD COLUMN IF NOT EXISTS tenant_id VARCHAR(255) DEFAULT 'default'
+    `);
+    await client.query(`
+      UPDATE lattice_skills 
+      SET tenant_id = 'default' 
+      WHERE tenant_id IS NULL
+    `);
+    await client.query(`
+      ALTER TABLE lattice_skills
+      ALTER COLUMN tenant_id SET NOT NULL
+    `);
+    await client.query(`
+      ALTER TABLE lattice_skills
+      ALTER COLUMN tenant_id DROP DEFAULT
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_skills_tenant_id 
+      ON lattice_skills(tenant_id)
+    `);
+  },
+  down: async (client) => {
+    await client.query(
+      "DROP INDEX IF EXISTS idx_lattice_skills_tenant_id"
+    );
+    await client.query(
+      "ALTER TABLE lattice_skills DROP COLUMN IF EXISTS tenant_id"
+    );
+  }
+};
+
+// src/migrations/skill_pk_migration.ts
+var changeSkillPrimaryKey = {
+  version: 17,
+  name: "change_skill_primary_key",
+  up: async (client) => {
+    const tableExists = await client.query(`
+      SELECT EXISTS (
+        SELECT FROM information_schema.tables 
+        WHERE table_name = 'lattice_skills'
+      )
+    `);
+    if (!tableExists.rows[0].exists) {
+      return;
+    }
+    const pkResult = await client.query(`
+      SELECT a.attname as column_name
+      FROM pg_index i
+      JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey)
+      WHERE i.indrelid = 'lattice_skills'::regclass
+      AND i.indisprimary
+    `);
+    const pkColumns = pkResult.rows.map((row) => row.column_name);
+    if (pkColumns.includes("tenant_id") && pkColumns.includes("id")) {
+      console.log("Skill table primary key already correct (tenant_id, id)");
+      return;
+    }
+    if (pkColumns.length === 1 && pkColumns[0] === "id") {
+      console.log("Changing skill table primary key from (id) to (tenant_id, id)");
+      const tenantIdExists = await client.query(`
+        SELECT EXISTS (
+          SELECT FROM information_schema.columns 
+          WHERE table_name = 'lattice_skills' 
+          AND column_name = 'tenant_id'
+        )
+      `);
+      if (!tenantIdExists.rows[0].exists) {
+        await client.query(`
+          ALTER TABLE lattice_skills
+          ADD COLUMN tenant_id VARCHAR(255) DEFAULT 'default'
+        `);
+      }
+      await client.query(`
+        UPDATE lattice_skills 
+        SET tenant_id = 'default' 
+        WHERE tenant_id IS NULL
+      `);
+      await client.query(`
+        ALTER TABLE lattice_skills
+        ALTER COLUMN tenant_id SET NOT NULL
+      `);
+      await client.query(`
+        ALTER TABLE lattice_skills 
+        DROP CONSTRAINT IF EXISTS lattice_skills_pkey
+      `);
+      await client.query(`
+        ALTER TABLE lattice_skills 
+        ADD PRIMARY KEY (tenant_id, id)
+      `);
+      console.log("Skill table primary key changed successfully to (tenant_id, id)");
+    }
+  },
+  down: async (client) => {
+    console.warn("Down migration for changeSkillPrimaryKey is not supported");
+  }
+};
+
 // src/stores/PostgreSQLSkillStore.ts
 var PostgreSQLSkillStore = class {
   constructor(options) {
     this.initialized = false;
     this.ownsPool = true;
+    this.initPromise = null;
     if (typeof options.poolConfig === "string") {
       this.pool = new Pool4({ connectionString: options.poolConfig });
     } else {
@@ -1204,6 +1583,8 @@ var PostgreSQLSkillStore = class {
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createSkillsTable);
+    this.migrationManager.register(addSkillTenantId);
+    this.migrationManager.register(changeSkillPrimaryKey);
     if (options.autoMigrate !== false) {
       this.initialize().catch((error) => {
         console.error("Failed to initialize PostgreSQLSkillStore:", error);
@@ -1211,28 +1592,32 @@ var PostgreSQLSkillStore = class {
       });
     }
   }
-  /**
-   * Dispose resources and close the connection pool
-   * Should be called when the store is no longer needed
-   */
-  async dispose() {
-    if (this.ownsPool && this.pool) {
-      await this.pool.end();
-    }
-  }
   /**
    * Initialize the store and run migrations
+   * Uses a promise-based lock to prevent concurrent initialization
    */
   async initialize() {
     if (this.initialized) {
       return;
     }
-    await this.migrationManager.migrate();
-    this.initialized = true;
+    if (this.initPromise) {
+      return this.initPromise;
+    }
+    this.initPromise = (async () => {
+      try {
+        await this.migrationManager.migrate();
+        this.initialized = true;
+      } finally {
+        this.initPromise = null;
+      }
+    })();
+    return this.initPromise;
+  }
+  async dispose() {
+    if (this.ownsPool && this.pool) {
+      await this.pool.end();
+    }
   }
-  /**
-   * Ensure store is initialized
-   */
   async ensureInitialized() {
     if (!this.initialized) {
       await this.initialize();
@@ -1244,43 +1629,46 @@ var PostgreSQLSkillStore = class {
   mapRowToSkill(row) {
     return {
       id: row.id,
+      tenantId: row.tenant_id,
       name: row.name,
       description: row.description,
       license: row.license || void 0,
       compatibility: row.compatibility || void 0,
       metadata: row.metadata || {},
       content: row.content || void 0,
-      subSkills: Array.isArray(row.sub_skills) && row.sub_skills.length > 0 ? row.sub_skills : void 0,
+      subSkills: Array.isArray(row.sub_skills) ? row.sub_skills : void 0,
       createdAt: row.created_at,
       updatedAt: row.updated_at
     };
   }
   /**
-   * Get all skills
+   * Get all skills for a tenant
    */
-  async getAllSkills() {
+  async getAllSkills(tenantId) {
     await this.ensureInitialized();
     const result = await this.pool.query(
       `
-      SELECT id, name, description, license, compatibility, metadata, content, sub_skills, created_at, updated_at
+      SELECT id, tenant_id, name, description, license, compatibility, metadata, content, sub_skills, created_at, updated_at
       FROM lattice_skills
+      WHERE tenant_id = $1
       ORDER BY created_at DESC
-    `
+    `,
+      [tenantId]
     );
     return result.rows.map(this.mapRowToSkill);
   }
   /**
-   * Get skill by ID
+   * Get skill by ID for a tenant
    */
-  async getSkillById(id) {
+  async getSkillById(tenantId, id) {
     await this.ensureInitialized();
     const result = await this.pool.query(
       `
-      SELECT id, name, description, license, compatibility, metadata, content, sub_skills, created_at, updated_at
+      SELECT id, tenant_id, name, description, license, compatibility, metadata, content, sub_skills, created_at, updated_at
       FROM lattice_skills
-      WHERE id = $1
+      WHERE tenant_id = $1 AND id = $2
     `,
-      [id]
+      [tenantId, id]
     );
     if (result.rows.length === 0) {
       return null;
@@ -1288,17 +1676,17 @@ var PostgreSQLSkillStore = class {
     return this.mapRowToSkill(result.rows[0]);
   }
   /**
-   * Create a new skill
+   * Create a new skill for a tenant
    */
-  async createSkill(id, data) {
+  async createSkill(tenantId, id, data) {
     await this.ensureInitialized();
     const now = /* @__PURE__ */ new Date();
-    const metadata = data.metadata || {};
     await this.pool.query(
       `
-      INSERT INTO lattice_skills (id, name, description, license, compatibility, metadata, content, sub_skills, created_at, updated_at)
-      VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+      INSERT INTO lattice_skills (id, tenant_id, name, description, license, compatibility, metadata, content, sub_skills, created_at, updated_at)
+      VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
       ON CONFLICT (id) DO UPDATE SET
+        tenant_id = EXCLUDED.tenant_id,
         name = EXCLUDED.name,
         description = EXCLUDED.description,
         license = EXCLUDED.license,
@@ -1310,166 +1698,180 @@ var PostgreSQLSkillStore = class {
     `,
       [
         id,
+        tenantId,
         data.name,
         data.description,
         data.license || null,
         data.compatibility || null,
-        JSON.stringify(metadata),
+        JSON.stringify(data.metadata || {}),
         data.content || null,
         JSON.stringify(data.subSkills || []),
         now,
         now
       ]
     );
-    return this.getSkillById(id);
+    return {
+      id,
+      tenantId,
+      name: data.name,
+      description: data.description,
+      license: data.license,
+      compatibility: data.compatibility,
+      metadata: data.metadata || {},
+      content: data.content,
+      subSkills: data.subSkills,
+      createdAt: now,
+      updatedAt: now
+    };
   }
   /**
-   * Update an existing skill
+   * Update an existing skill for a tenant
    */
-  async updateSkill(id, updates) {
+  async updateSkill(tenantId, id, updates) {
     await this.ensureInitialized();
+    const existing = await this.getSkillById(tenantId, id);
+    if (!existing) {
+      return null;
+    }
     const updateFields = [];
-    const values = [];
+    const updateValues = [];
     let paramIndex = 1;
     if (updates.name !== void 0) {
       updateFields.push(`name = $${paramIndex++}`);
-      values.push(updates.name);
+      updateValues.push(updates.name);
     }
     if (updates.description !== void 0) {
       updateFields.push(`description = $${paramIndex++}`);
-      values.push(updates.description);
+      updateValues.push(updates.description);
     }
     if (updates.license !== void 0) {
       updateFields.push(`license = $${paramIndex++}`);
-      values.push(updates.license || null);
+      updateValues.push(updates.license || null);
     }
     if (updates.compatibility !== void 0) {
       updateFields.push(`compatibility = $${paramIndex++}`);
-      values.push(updates.compatibility || null);
+      updateValues.push(updates.compatibility || null);
     }
     if (updates.metadata !== void 0) {
       updateFields.push(`metadata = $${paramIndex++}`);
-      values.push(JSON.stringify(updates.metadata || {}));
+      updateValues.push(JSON.stringify(updates.metadata || {}));
     }
     if (updates.content !== void 0) {
       updateFields.push(`content = $${paramIndex++}`);
-      values.push(updates.content || null);
+      updateValues.push(updates.content || null);
     }
     if (updates.subSkills !== void 0) {
       updateFields.push(`sub_skills = $${paramIndex++}`);
-      values.push(JSON.stringify(updates.subSkills || []));
+      updateValues.push(JSON.stringify(updates.subSkills || []));
     }
     if (updateFields.length === 0) {
-      return this.getSkillById(id);
+      return existing;
     }
     updateFields.push(`updated_at = $${paramIndex++}`);
-    values.push(/* @__PURE__ */ new Date());
-    values.push(id);
+    updateValues.push(/* @__PURE__ */ new Date());
+    updateValues.push(tenantId);
+    updateValues.push(id);
     await this.pool.query(
       `
       UPDATE lattice_skills
       SET ${updateFields.join(", ")}
-      WHERE id = $${paramIndex}
+      WHERE tenant_id = $${paramIndex++} AND id = $${paramIndex}
     `,
-      values
+      updateValues
     );
-    return this.getSkillById(id);
+    return await this.getSkillById(tenantId, id);
   }
   /**
-   * Delete a skill by ID
+   * Delete a skill by ID for a tenant
    */
-  async deleteSkill(id) {
+  async deleteSkill(tenantId, id) {
     await this.ensureInitialized();
     const result = await this.pool.query(
       `
       DELETE FROM lattice_skills
-      WHERE id = $1
+      WHERE tenant_id = $1 AND id = $2
     `,
-      [id]
+      [tenantId, id]
     );
     return result.rowCount !== null && result.rowCount > 0;
   }
   /**
-   * Check if skill exists
+   * Check if skill exists for a tenant
    */
-  async hasSkill(id) {
+  async hasSkill(tenantId, id) {
     await this.ensureInitialized();
     const result = await this.pool.query(
       `
-      SELECT COUNT(*) as count
-      FROM lattice_skills
-      WHERE id = $1
+      SELECT 1 FROM lattice_skills
+      WHERE tenant_id = $1 AND id = $2
+      LIMIT 1
     `,
-      [id]
+      [tenantId, id]
     );
-    return parseInt(result.rows[0].count, 10) > 0;
+    return result.rows.length > 0;
   }
   /**
-   * Search skills by metadata
+   * Search skills by metadata within a tenant
    */
-  async searchByMetadata(metadataKey, metadataValue) {
+  async searchByMetadata(tenantId, metadataKey, metadataValue) {
     await this.ensureInitialized();
     const result = await this.pool.query(
       `
-      SELECT id, name, description, license, compatibility, metadata, content, sub_skills, created_at, updated_at
+      SELECT id, tenant_id, name, description, license, compatibility, metadata, content, sub_skills, created_at, updated_at
       FROM lattice_skills
-      WHERE metadata->>$1 = $2
+      WHERE tenant_id = $1 AND metadata ->> $2 = $3
       ORDER BY created_at DESC
     `,
-      [metadataKey, metadataValue]
+      [tenantId, metadataKey, metadataValue]
     );
     return result.rows.map(this.mapRowToSkill);
   }
   /**
-   * Filter skills by compatibility
+   * Filter skills by compatibility within a tenant
    */
-  async filterByCompatibility(compatibility) {
+  async filterByCompatibility(tenantId, compatibility) {
     await this.ensureInitialized();
     const result = await this.pool.query(
       `
-      SELECT id, name, description, license, compatibility, metadata, content, sub_skills, created_at, updated_at
+      SELECT id, tenant_id, name, description, license, compatibility, metadata, content, sub_skills, created_at, updated_at
       FROM lattice_skills
-      WHERE compatibility = $1
+      WHERE tenant_id = $1 AND compatibility = $2
       ORDER BY created_at DESC
     `,
-      [compatibility]
+      [tenantId, compatibility]
     );
     return result.rows.map(this.mapRowToSkill);
   }
   /**
-   * Filter skills by license
+   * Filter skills by license within a tenant
    */
-  async filterByLicense(license) {
+  async filterByLicense(tenantId, license) {
     await this.ensureInitialized();
     const result = await this.pool.query(
       `
-      SELECT id, name, description, license, compatibility, metadata, content, sub_skills, created_at, updated_at
+      SELECT id, tenant_id, name, description, license, compatibility, metadata, content, sub_skills, created_at, updated_at
       FROM lattice_skills
-      WHERE license = $1
+      WHERE tenant_id = $1 AND license = $2
       ORDER BY created_at DESC
     `,
-      [license]
+      [tenantId, license]
     );
     return result.rows.map(this.mapRowToSkill);
   }
   /**
-   * Get sub-skills of a parent skill
+   * Get sub-skills of a parent skill within a tenant
+   * Note: This searches for skills that have the parent skill name in their subSkills array
    */
-  async getSubSkills(parentSkillName) {
+  async getSubSkills(tenantId, parentSkillName) {
     await this.ensureInitialized();
-    const parentSkill = await this.getSkillById(parentSkillName);
-    if (!parentSkill || !parentSkill.subSkills || parentSkill.subSkills.length === 0) {
-      return [];
-    }
-    const placeholders = parentSkill.subSkills.map((_, index) => `$${index + 1}`).join(", ");
     const result = await this.pool.query(
       `
-      SELECT id, name, description, license, compatibility, metadata, content, sub_skills, created_at, updated_at
+      SELECT id, tenant_id, name, description, license, compatibility, metadata, content, sub_skills, created_at, updated_at
       FROM lattice_skills
-      WHERE name IN (${placeholders})
+      WHERE tenant_id = $1 AND sub_skills @> to_jsonb($2::text)
       ORDER BY created_at DESC
     `,
-      parentSkill.subSkills
+      [tenantId, JSON.stringify([parentSkillName])]
     );
     return result.rows.map(this.mapRowToSkill);
   }
@@ -3568,6 +3970,13 @@ export {
   PostgreSQLUserStore,
   PostgreSQLUserTenantLinkStore,
   PostgreSQLWorkspaceStore,
+  addAssistantTenantId,
+  addScheduleTenantId,
+  addSkillTenantId,
+  addThreadTenantId,
+  changeAssistantPrimaryKey,
+  changeSkillPrimaryKey,
+  changeThreadPrimaryKey,
   createAssistantsTable,
   createDatabaseConfigsTable,
   createMcpServerConfigsTable,