@axiom-lattice/local-stores 1.0.1

package/src/stores/LocalScheduleStorage.ts

@@ -0,0 +1,287 @@
+/**
+ * Local SQLite implementation of ScheduleStorage.
+ */
+
+import { DatabaseWrapper } from "../database";
+import {
+  ScheduleStorage,
+  ScheduledTaskDefinition,
+  ScheduledTaskStatus,
+  ScheduleExecutionType,
+} from "@axiom-lattice/protocols";
+import { ensureTable } from "../database";
+
+const DDL = `
+CREATE TABLE IF NOT EXISTS lt_scheduled_tasks (
+  task_id TEXT PRIMARY KEY,
+  task_type TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  payload TEXT NOT NULL DEFAULT '{}',
+  assistant_id TEXT,
+  thread_id TEXT,
+  execution_type TEXT NOT NULL,
+  execute_at TEXT,
+  delay_ms INTEGER,
+  cron_expression TEXT,
+  timezone TEXT,
+  next_run_at TEXT,
+  last_run_at TEXT,
+  status TEXT NOT NULL DEFAULT 'pending',
+  run_count INTEGER NOT NULL DEFAULT 0,
+  max_runs INTEGER,
+  retry_count INTEGER NOT NULL DEFAULT 0,
+  max_retries INTEGER NOT NULL DEFAULT 0,
+  last_error TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  expires_at TEXT,
+  metadata TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_lt_st_status ON lt_scheduled_tasks(status);
+CREATE INDEX IF NOT EXISTS idx_lt_st_type ON lt_scheduled_tasks(task_type);
+CREATE INDEX IF NOT EXISTS idx_lt_st_tenant ON lt_scheduled_tasks(tenant_id);
+`;
+
+interface TaskRow {
+  task_id: string;
+  task_type: string;
+  tenant_id: string;
+  payload: string;
+  assistant_id: string | null;
+  thread_id: string | null;
+  execution_type: string;
+  execute_at: string | null;
+  delay_ms: number | null;
+  cron_expression: string | null;
+  timezone: string | null;
+  next_run_at: string | null;
+  last_run_at: string | null;
+  status: string;
+  run_count: number;
+  max_runs: number | null;
+  retry_count: number;
+  max_retries: number;
+  last_error: string | null;
+  created_at: string;
+  updated_at: string;
+  expires_at: string | null;
+  metadata: string | null;
+}
+
+export class LocalScheduleStorage implements ScheduleStorage {
+  private db: DatabaseWrapper;
+
+  constructor(db: DatabaseWrapper) {
+    this.db = db;
+    ensureTable(db, DDL);
+  }
+
+  async save(task: ScheduledTaskDefinition): Promise<void> {
+    this.db.prepare(
+      `INSERT INTO lt_scheduled_tasks (
+         task_id, task_type, tenant_id, payload, assistant_id, thread_id, execution_type,
+         execute_at, delay_ms, cron_expression, timezone, next_run_at, last_run_at,
+         status, run_count, max_runs, retry_count, max_retries, last_error,
+         created_at, updated_at, expires_at, metadata
+       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(task_id) DO UPDATE SET
+         task_type = excluded.task_type, tenant_id = excluded.tenant_id,
+         payload = excluded.payload, assistant_id = excluded.assistant_id,
+         thread_id = excluded.thread_id, execution_type = excluded.execution_type,
+         execute_at = excluded.execute_at, delay_ms = excluded.delay_ms,
+         cron_expression = excluded.cron_expression, timezone = excluded.timezone,
+         next_run_at = excluded.next_run_at, last_run_at = excluded.last_run_at,
+         status = excluded.status, run_count = excluded.run_count,
+         max_runs = excluded.max_runs, retry_count = excluded.retry_count,
+         max_retries = excluded.max_retries, last_error = excluded.last_error,
+         updated_at = excluded.updated_at, expires_at = excluded.expires_at,
+         metadata = excluded.metadata`,
+    ).run(
+      task.taskId, task.taskType, task.tenantId, JSON.stringify(task.payload),
+      task.assistantId ?? null, task.threadId ?? null, task.executionType,
+      task.executeAt ? new Date(task.executeAt).toISOString() : null,
+      task.delayMs ?? null, task.cronExpression ?? null, task.timezone ?? null,
+      task.nextRunAt ? new Date(task.nextRunAt).toISOString() : null,
+      task.lastRunAt ? new Date(task.lastRunAt).toISOString() : null,
+      task.status, task.runCount, task.maxRuns ?? null,
+      task.retryCount, task.maxRetries, task.lastError ?? null,
+      new Date(task.createdAt).toISOString(), new Date(task.updatedAt).toISOString(),
+      task.expiresAt ? new Date(task.expiresAt).toISOString() : null,
+      task.metadata ? JSON.stringify(task.metadata) : null,
+    );
+  }
+
+  async get(taskId: string): Promise<ScheduledTaskDefinition | null> {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_scheduled_tasks WHERE task_id = ?`,
+    ).get(taskId) as unknown as TaskRow | undefined;
+    return row ? mapRowToTask(row) : null;
+  }
+
+  async update(taskId: string, updates: Partial<ScheduledTaskDefinition>): Promise<void> {
+    const setClauses: string[] = [];
+    const values: unknown[] = [];
+
+    if (updates.taskType !== undefined) { setClauses.push("task_type = ?"); values.push(updates.taskType); }
+    if (updates.tenantId !== undefined) { setClauses.push("tenant_id = ?"); values.push(updates.tenantId); }
+    if (updates.payload !== undefined) { setClauses.push("payload = ?"); values.push(JSON.stringify(updates.payload)); }
+    if (updates.assistantId !== undefined) { setClauses.push("assistant_id = ?"); values.push(updates.assistantId ?? null); }
+    if (updates.threadId !== undefined) { setClauses.push("thread_id = ?"); values.push(updates.threadId ?? null); }
+    if (updates.executionType !== undefined) { setClauses.push("execution_type = ?"); values.push(updates.executionType); }
+    if (updates.executeAt !== undefined) { setClauses.push("execute_at = ?"); values.push(updates.executeAt ? new Date(updates.executeAt).toISOString() : null); }
+    if (updates.delayMs !== undefined) { setClauses.push("delay_ms = ?"); values.push(updates.delayMs ?? null); }
+    if (updates.cronExpression !== undefined) { setClauses.push("cron_expression = ?"); values.push(updates.cronExpression ?? null); }
+    if (updates.timezone !== undefined) { setClauses.push("timezone = ?"); values.push(updates.timezone ?? null); }
+    if (updates.nextRunAt !== undefined) { setClauses.push("next_run_at = ?"); values.push(updates.nextRunAt ? new Date(updates.nextRunAt).toISOString() : null); }
+    if (updates.lastRunAt !== undefined) { setClauses.push("last_run_at = ?"); values.push(updates.lastRunAt ? new Date(updates.lastRunAt).toISOString() : null); }
+    if (updates.status !== undefined) { setClauses.push("status = ?"); values.push(updates.status); }
+    if (updates.runCount !== undefined) { setClauses.push("run_count = ?"); values.push(updates.runCount); }
+    if (updates.maxRuns !== undefined) { setClauses.push("max_runs = ?"); values.push(updates.maxRuns ?? null); }
+    if (updates.retryCount !== undefined) { setClauses.push("retry_count = ?"); values.push(updates.retryCount); }
+    if (updates.maxRetries !== undefined) { setClauses.push("max_retries = ?"); values.push(updates.maxRetries); }
+    if (updates.lastError !== undefined) { setClauses.push("last_error = ?"); values.push(updates.lastError ?? null); }
+    if (updates.expiresAt !== undefined) { setClauses.push("expires_at = ?"); values.push(updates.expiresAt ? new Date(updates.expiresAt).toISOString() : null); }
+    if (updates.metadata !== undefined) { setClauses.push("metadata = ?"); values.push(updates.metadata ? JSON.stringify(updates.metadata) : null); }
+
+    if (setClauses.length === 0) return;
+
+    setClauses.push("updated_at = ?");
+    values.push(new Date().toISOString());
+    values.push(taskId);
+
+    this.db.prepare(
+      `UPDATE lt_scheduled_tasks SET ${setClauses.join(", ")} WHERE task_id = ?`,
+    ).run(...values);
+  }
+
+  async delete(taskId: string): Promise<void> {
+    this.db.prepare(`DELETE FROM lt_scheduled_tasks WHERE task_id = ?`).run(taskId);
+  }
+
+  async getActiveTasks(): Promise<ScheduledTaskDefinition[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_scheduled_tasks WHERE status IN ('pending', 'paused') ORDER BY created_at ASC`,
+    ).all() as unknown as TaskRow[];
+    return rows.map(mapRowToTask);
+  }
+
+  async getTasksByType(taskType: string): Promise<ScheduledTaskDefinition[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_scheduled_tasks WHERE task_type = ? ORDER BY created_at DESC`,
+    ).all(taskType) as unknown as TaskRow[];
+    return rows.map(mapRowToTask);
+  }
+
+  async getTasksByStatus(status: ScheduledTaskStatus): Promise<ScheduledTaskDefinition[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_scheduled_tasks WHERE status = ? ORDER BY created_at DESC`,
+    ).all(status) as unknown as TaskRow[];
+    return rows.map(mapRowToTask);
+  }
+
+  async getTasksByExecutionType(executionType: ScheduleExecutionType): Promise<ScheduledTaskDefinition[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_scheduled_tasks WHERE execution_type = ? ORDER BY created_at DESC`,
+    ).all(executionType) as unknown as TaskRow[];
+    return rows.map(mapRowToTask);
+  }
+
+  async getTasksByAssistantId(assistantId: string): Promise<ScheduledTaskDefinition[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_scheduled_tasks WHERE assistant_id = ? ORDER BY created_at DESC`,
+    ).all(assistantId) as unknown as TaskRow[];
+    return rows.map(mapRowToTask);
+  }
+
+  async getTasksByThreadId(threadId: string): Promise<ScheduledTaskDefinition[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_scheduled_tasks WHERE thread_id = ? ORDER BY created_at DESC`,
+    ).all(threadId) as unknown as TaskRow[];
+    return rows.map(mapRowToTask);
+  }
+
+  async getAllTasks(filters?: {
+    tenantId?: string; status?: ScheduledTaskStatus;
+    executionType?: ScheduleExecutionType; taskType?: string;
+    assistantId?: string; threadId?: string;
+    limit?: number; offset?: number;
+  }): Promise<ScheduledTaskDefinition[]> {
+    const conditions: string[] = [];
+    const values: unknown[] = [];
+
+    if (filters?.tenantId !== undefined) { conditions.push("tenant_id = ?"); values.push(filters.tenantId); }
+    if (filters?.status !== undefined) { conditions.push("status = ?"); values.push(filters.status); }
+    if (filters?.executionType !== undefined) { conditions.push("execution_type = ?"); values.push(filters.executionType); }
+    if (filters?.taskType !== undefined) { conditions.push("task_type = ?"); values.push(filters.taskType); }
+    if (filters?.assistantId !== undefined) { conditions.push("assistant_id = ?"); values.push(filters.assistantId); }
+    if (filters?.threadId !== undefined) { conditions.push("thread_id = ?"); values.push(filters.threadId); }
+
+    let query = `SELECT * FROM lt_scheduled_tasks`;
+    if (conditions.length > 0) query += ` WHERE ${conditions.join(" AND ")}`;
+    query += ` ORDER BY created_at DESC`;
+
+    if (filters?.limit !== undefined) { query += ` LIMIT ?`; values.push(filters.limit); }
+    if (filters?.offset !== undefined) { query += ` OFFSET ?`; values.push(filters.offset); }
+
+    const rows = this.db.prepare(query).all(...values) as unknown as TaskRow[];
+    return rows.map(mapRowToTask);
+  }
+
+  async countTasks(filters?: {
+    tenantId?: string; status?: ScheduledTaskStatus;
+    executionType?: ScheduleExecutionType; taskType?: string;
+    assistantId?: string; threadId?: string;
+  }): Promise<number> {
+    const conditions: string[] = [];
+    const values: unknown[] = [];
+
+    if (filters?.tenantId !== undefined) { conditions.push("tenant_id = ?"); values.push(filters.tenantId); }
+    if (filters?.status !== undefined) { conditions.push("status = ?"); values.push(filters.status); }
+    if (filters?.executionType !== undefined) { conditions.push("execution_type = ?"); values.push(filters.executionType); }
+    if (filters?.taskType !== undefined) { conditions.push("task_type = ?"); values.push(filters.taskType); }
+    if (filters?.assistantId !== undefined) { conditions.push("assistant_id = ?"); values.push(filters.assistantId); }
+    if (filters?.threadId !== undefined) { conditions.push("thread_id = ?"); values.push(filters.threadId); }
+
+    let query = `SELECT COUNT(*) as count FROM lt_scheduled_tasks`;
+    if (conditions.length > 0) query += ` WHERE ${conditions.join(" AND ")}`;
+
+    const row = this.db.prepare(query).get(...values) as { count: number };
+    return row.count;
+  }
+
+  async deleteOldTasks(olderThanMs: number): Promise<number> {
+    const cutoff = new Date(Date.now() - olderThanMs).toISOString();
+    const result = this.db.prepare(
+      `DELETE FROM lt_scheduled_tasks WHERE status IN ('completed', 'cancelled', 'failed') AND updated_at < ?`,
+    ).run(cutoff);
+    return result.changes;
+  }
+}
+
+function mapRowToTask(row: TaskRow): ScheduledTaskDefinition {
+  return {
+    taskId: row.task_id,
+    taskType: row.task_type,
+    tenantId: row.tenant_id,
+    payload: JSON.parse(row.payload || "{}"),
+    assistantId: row.assistant_id ?? undefined,
+    threadId: row.thread_id ?? undefined,
+    executionType: row.execution_type as ScheduleExecutionType,
+    executeAt: row.execute_at ? new Date(row.execute_at).getTime() : undefined,
+    delayMs: row.delay_ms ?? undefined,
+    cronExpression: row.cron_expression ?? undefined,
+    timezone: row.timezone ?? undefined,
+    nextRunAt: row.next_run_at ? new Date(row.next_run_at).getTime() : undefined,
+    lastRunAt: row.last_run_at ? new Date(row.last_run_at).getTime() : undefined,
+    status: row.status as ScheduledTaskStatus,
+    runCount: row.run_count,
+    maxRuns: row.max_runs ?? undefined,
+    retryCount: row.retry_count,
+    maxRetries: row.max_retries,
+    lastError: row.last_error ?? undefined,
+    createdAt: new Date(row.created_at).getTime(),
+    updatedAt: new Date(row.updated_at).getTime(),
+    expiresAt: row.expires_at ? new Date(row.expires_at).getTime() : undefined,
+    metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+  };
+}

package/src/stores/LocalSkillStore.ts

@@ -0,0 +1,188 @@
+/**
+ * Local SQLite implementation of SkillStore.
+ */
+
+import { DatabaseWrapper } from "../database";
+import type {
+  SkillStore,
+  Skill,
+  CreateSkillRequest,
+  SkillStoreContext,
+} from "@axiom-lattice/protocols";
+import { ensureTable, nowISO, parseISO } from "../database";
+
+const DDL = `
+CREATE TABLE IF NOT EXISTS lt_skills (
+  id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  name TEXT NOT NULL,
+  description TEXT NOT NULL,
+  license TEXT,
+  compatibility TEXT,
+  metadata TEXT DEFAULT '{}',
+  content TEXT,
+  sub_skills TEXT DEFAULT '[]',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (tenant_id, id)
+);
+`;
+
+interface SkillRow {
+  id: string;
+  tenant_id: string;
+  name: string;
+  description: string;
+  license: string | null;
+  compatibility: string | null;
+  metadata: string;
+  content: string | null;
+  sub_skills: string;
+  created_at: string;
+  updated_at: string;
+}
+
+export class LocalSkillStore implements SkillStore {
+  private db: DatabaseWrapper;
+
+  constructor(db: DatabaseWrapper) {
+    this.db = db;
+    ensureTable(db, DDL);
+  }
+
+  async getAllSkills(tenantId: string, _context?: SkillStoreContext): Promise<Skill[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_skills WHERE tenant_id = ? ORDER BY created_at DESC`,
+    ).all(tenantId) as unknown as SkillRow[];
+    return rows.map(mapRowToSkill);
+  }
+
+  async getSkillById(tenantId: string, id: string, _context?: SkillStoreContext): Promise<Skill | null> {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_skills WHERE tenant_id = ? AND id = ?`,
+    ).get(tenantId, id) as unknown as SkillRow | undefined;
+    return row ? mapRowToSkill(row) : null;
+  }
+
+  async createSkill(tenantId: string, id: string, data: CreateSkillRequest, _context?: SkillStoreContext): Promise<Skill> {
+    const now = nowISO();
+
+    this.db.prepare(
+      `INSERT INTO lt_skills (id, tenant_id, name, description, license, compatibility, metadata, content, sub_skills, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(tenant_id, id) DO UPDATE SET
+         name = excluded.name, description = excluded.description,
+         license = excluded.license, compatibility = excluded.compatibility,
+         metadata = excluded.metadata, content = excluded.content,
+         sub_skills = excluded.sub_skills, updated_at = excluded.updated_at`,
+    ).run(id, tenantId, data.name, data.description,
+      data.license || null, data.compatibility || null,
+      JSON.stringify(data.metadata || {}), data.content || null,
+      JSON.stringify(data.subSkills || []), now, now);
+
+    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: parseISO(now), updatedAt: parseISO(now),
+    };
+  }
+
+  async updateSkill(
+    tenantId: string, id: string, updates: Partial<CreateSkillRequest>, _context?: SkillStoreContext,
+  ): Promise<Skill | null> {
+    const existing = await this.getSkillById(tenantId, id);
+    if (!existing) return null;
+
+    const setClauses: string[] = [];
+    const values: unknown[] = [];
+
+    if (updates.name !== undefined) { setClauses.push("name = ?"); values.push(updates.name); }
+    if (updates.description !== undefined) { setClauses.push("description = ?"); values.push(updates.description); }
+    if (updates.license !== undefined) { setClauses.push("license = ?"); values.push(updates.license || null); }
+    if (updates.compatibility !== undefined) { setClauses.push("compatibility = ?"); values.push(updates.compatibility || null); }
+    if (updates.metadata !== undefined) { setClauses.push("metadata = ?"); values.push(JSON.stringify(updates.metadata || {})); }
+    if (updates.content !== undefined) { setClauses.push("content = ?"); values.push(updates.content || null); }
+    if (updates.subSkills !== undefined) { setClauses.push("sub_skills = ?"); values.push(JSON.stringify(updates.subSkills || [])); }
+
+    if (setClauses.length === 0) return existing;
+
+    const now = nowISO();
+    setClauses.push("updated_at = ?");
+    values.push(now);
+    values.push(tenantId, id);
+
+    this.db.prepare(
+      `UPDATE lt_skills SET ${setClauses.join(", ")} WHERE tenant_id = ? AND id = ?`,
+    ).run(...values);
+
+    return this.getSkillById(tenantId, id);
+  }
+
+  async deleteSkill(tenantId: string, id: string, _context?: SkillStoreContext): Promise<boolean> {
+    const result = this.db.prepare(
+      `DELETE FROM lt_skills WHERE tenant_id = ? AND id = ?`,
+    ).run(tenantId, id);
+    return result.changes > 0;
+  }
+
+  async hasSkill(tenantId: string, id: string, _context?: SkillStoreContext): Promise<boolean> {
+    const row = this.db.prepare(
+      `SELECT 1 FROM lt_skills WHERE tenant_id = ? AND id = ? LIMIT 1`,
+    ).get(tenantId, id);
+    return row !== undefined;
+  }
+
+  async searchByMetadata(
+    tenantId: string, metadataKey: string, metadataValue: string, _context?: SkillStoreContext,
+  ): Promise<Skill[]> {
+    // SQLite doesn't have JSONB operators, so filter in JS
+    const all = await this.getAllSkills(tenantId);
+    return all.filter((s) => s.metadata?.[metadataKey] === metadataValue);
+  }
+
+  async filterByCompatibility(tenantId: string, compatibility: string, _context?: SkillStoreContext): Promise<Skill[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_skills WHERE tenant_id = ? AND compatibility = ? ORDER BY created_at DESC`,
+    ).all(tenantId, compatibility) as unknown as SkillRow[];
+    return rows.map(mapRowToSkill);
+  }
+
+  async filterByLicense(tenantId: string, license: string, _context?: SkillStoreContext): Promise<Skill[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_skills WHERE tenant_id = ? AND license = ? ORDER BY created_at DESC`,
+    ).all(tenantId, license) as unknown as SkillRow[];
+    return rows.map(mapRowToSkill);
+  }
+
+  async getSubSkills(tenantId: string, parentSkillName: string, _context?: SkillStoreContext): Promise<Skill[]> {
+    // SQLite doesn't have @> for JSON arrays, so filter in JS
+    const all = await this.getAllSkills(tenantId);
+    return all.filter((s) => s.subSkills?.includes(parentSkillName));
+  }
+
+  async listSkillResources?(_tenantId: string, _id: string, _context?: SkillStoreContext): Promise<string[]> {
+    return [];
+  }
+
+  async loadSkillResource?(_tenantId: string, _id: string, _resourcePath: string, _context?: SkillStoreContext): Promise<string | null> {
+    return null;
+  }
+}
+
+function mapRowToSkill(row: SkillRow): Skill {
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    name: row.name,
+    description: row.description,
+    license: row.license || undefined,
+    compatibility: row.compatibility || undefined,
+    metadata: JSON.parse(row.metadata || "{}"),
+    content: row.content || undefined,
+    subSkills: JSON.parse(row.sub_skills || "[]"),
+    createdAt: parseISO(row.created_at),
+    updatedAt: parseISO(row.updated_at),
+  };
+}

package/src/stores/LocalTenantStore.ts

@@ -0,0 +1,128 @@
+/**
+ * Local SQLite implementation of TenantStore.
+ */
+
+import { DatabaseWrapper } from "../database";
+import type {
+  TenantStore,
+  Tenant,
+  TenantStatus,
+  CreateTenantRequest,
+  UpdateTenantRequest,
+} from "@axiom-lattice/protocols";
+import { ensureTable, nowISO, parseISO } from "../database";
+
+const DDL = `
+CREATE TABLE IF NOT EXISTS lt_tenants (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  description TEXT,
+  status TEXT NOT NULL DEFAULT 'active',
+  metadata TEXT DEFAULT '{}',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+`;
+
+interface TenantRow {
+  id: string;
+  name: string;
+  description: string | null;
+  status: string;
+  metadata: string;
+  created_at: string;
+  updated_at: string;
+}
+
+export class LocalTenantStore implements TenantStore {
+  private db: DatabaseWrapper;
+
+  constructor(db: DatabaseWrapper) {
+    this.db = db;
+    ensureTable(db, DDL);
+  }
+
+  async getAllTenants(): Promise<Tenant[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_tenants ORDER BY created_at DESC`,
+    ).all() as unknown as TenantRow[];
+    return rows.map(mapRowToTenant);
+  }
+
+  async getTenantById(id: string): Promise<Tenant | null> {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_tenants WHERE id = ?`,
+    ).get(id) as unknown as TenantRow | undefined;
+    return row ? mapRowToTenant(row) : null;
+  }
+
+  async createTenant(id: string, data: CreateTenantRequest): Promise<Tenant> {
+    const now = nowISO();
+    const status = data.status || "active";
+    const metadata = JSON.stringify(data.metadata || {});
+
+    this.db.prepare(
+      `INSERT INTO lt_tenants (id, name, description, status, metadata, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         name = excluded.name,
+         description = excluded.description,
+         status = excluded.status,
+         metadata = excluded.metadata,
+         updated_at = excluded.updated_at`,
+    ).run(id, data.name, data.description || null, status, metadata, now, now);
+
+    return {
+      id,
+      name: data.name,
+      description: data.description,
+      status: status as TenantStatus,
+      metadata: data.metadata,
+      createdAt: parseISO(now),
+      updatedAt: parseISO(now),
+    };
+  }
+
+  async updateTenant(id: string, updates: UpdateTenantRequest): Promise<Tenant | null> {
+    const existing = await this.getTenantById(id);
+    if (!existing) return null;
+
+    const setClauses: string[] = [];
+    const values: unknown[] = [];
+
+    if (updates.name !== undefined) { setClauses.push("name = ?"); values.push(updates.name); }
+    if (updates.description !== undefined) { setClauses.push("description = ?"); values.push(updates.description || null); }
+    if (updates.status !== undefined) { setClauses.push("status = ?"); values.push(updates.status); }
+    if (updates.metadata !== undefined) { setClauses.push("metadata = ?"); values.push(JSON.stringify(updates.metadata)); }
+
+    if (setClauses.length === 0) return existing;
+
+    const now = nowISO();
+    setClauses.push("updated_at = ?");
+    values.push(now);
+    values.push(id);
+
+    this.db.prepare(
+      `UPDATE lt_tenants SET ${setClauses.join(", ")} WHERE id = ?`,
+    ).run(...values);
+
+    return this.getTenantById(id);
+  }
+
+  async deleteTenant(id: string): Promise<boolean> {
+    const result = this.db.prepare(`DELETE FROM lt_tenants WHERE id = ?`).run(id);
+    return result.changes > 0;
+  }
+}
+
+function mapRowToTenant(row: TenantRow): Tenant {
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description || undefined,
+    status: row.status as TenantStatus,
+    metadata: JSON.parse(row.metadata || "{}"),
+    createdAt: parseISO(row.created_at),
+    updatedAt: parseISO(row.updated_at),
+  };
+}