mcoda 0.1.2 → 0.1.4

package/packages/core/src/workspace/WorkspaceManager.ts

@@ -1,234 +0,0 @@
-import path from "node:path";
-import { promises as fs } from "node:fs";
-import { randomUUID } from "node:crypto";
-import { PathHelper } from "@mcoda/shared";
-
-export interface WorkspaceResolution {
-  workspaceRoot: string;
-  workspaceId: string;
-  id: string;
-  legacyWorkspaceIds: string[];
-  mcodaDir: string;
-  workspaceDbPath: string;
-  globalDbPath: string;
-  config?: WorkspaceConfig;
-}
-
-export interface TelemetryPreferences {
-  optOut?: boolean;
-  strict?: boolean;
-  endpoint?: string;
-  authToken?: string;
-}
-
-export interface WorkspaceConfig {
-  mirrorDocs?: boolean;
-  branch?: string;
-  docdexUrl?: string;
-  velocity?: {
-    implementationSpPerHour?: number;
-    reviewSpPerHour?: number;
-    qaSpPerHour?: number;
-    alpha?: number;
-  };
-  telemetry?: TelemetryPreferences;
-}
-
-const fileExists = async (candidate: string): Promise<boolean> => {
-  try {
-    await fs.access(candidate);
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-const findGitRoot = async (start: string): Promise<string | undefined> => {
-  // Only consider the provided directory; do not walk upward.
-  const current = path.resolve(start);
-  const gitPath = path.join(current, ".git");
-  if (await fileExists(gitPath)) return current;
-  return undefined;
-};
-
-const findWorkspaceMarker = async (start: string): Promise<string | undefined> => {
-  // Only consider the provided directory; do not walk upward.
-  const current = path.resolve(start);
-  const marker = path.join(current, ".mcoda", "workspace.json");
-  const mcoda = path.join(current, ".mcoda");
-  if (await fileExists(marker)) return current;
-  if (await fileExists(mcoda)) return current;
-  return undefined;
-};
-
-const ensureGitignore = async (workspaceRoot: string): Promise<void> => {
-  const gitignorePath = path.join(workspaceRoot, ".gitignore");
-  const entry = ".mcoda/\n";
-  try {
-    const content = await fs.readFile(gitignorePath, "utf8");
-    if (content.includes(".mcoda/")) return;
-    await fs.writeFile(gitignorePath, `${content.trimEnd()}\n${entry}`, "utf8");
-  } catch {
-    await fs.writeFile(gitignorePath, entry, "utf8");
-  }
-};
-
-const readWorkspaceConfig = async (mcodaDir: string): Promise<WorkspaceConfig | undefined> => {
-  const configPath = path.join(mcodaDir, "config.json");
-  try {
-    const raw = await fs.readFile(configPath, "utf8");
-    return JSON.parse(raw) as WorkspaceConfig;
-  } catch {
-    return undefined;
-  }
-};
-
-type WorkspaceIdentity = { id: string; name?: string; createdAt?: string; legacyIds?: string[] };
-
-const readWorkspaceIdentity = async (mcodaDir: string): Promise<WorkspaceIdentity | undefined> => {
-  const workspacePath = path.join(mcodaDir, "workspace.json");
-  try {
-    const raw = await fs.readFile(workspacePath, "utf8");
-    const parsed = JSON.parse(raw) as WorkspaceIdentity;
-    if (parsed?.id) return parsed;
-    return undefined;
-  } catch {
-    return undefined;
-  }
-};
-
-const writeWorkspaceIdentity = async (
-  mcodaDir: string,
-  identity: WorkspaceIdentity,
-): Promise<void> => {
-  const workspacePath = path.join(mcodaDir, "workspace.json");
-  await fs.writeFile(workspacePath, JSON.stringify(identity, null, 2), "utf8");
-};
-
-const looksLikeWorkspaceId = (value: string): boolean =>
-  /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i.test(value.trim());
-
-const migrateWorkspaceDbIds = async (workspace: WorkspaceResolution, legacyIds: string[]): Promise<void> => {
-  if (!legacyIds.length) return;
-  try {
-    const { Connection } = await import("@mcoda/db");
-    const conn = await Connection.open(workspace.workspaceDbPath);
-    const db = conn.db;
-    const placeholders = legacyIds.map(() => "?").join(",");
-    const params = [workspace.workspaceId, ...legacyIds];
-    const tables = ["jobs", "command_runs", "token_usage"];
-    for (const table of tables) {
-      await db.run(`UPDATE ${table} SET workspace_id = ? WHERE workspace_id IN (${placeholders})`, params);
-    }
-    await conn.close();
-  } catch {
-    /* best effort */
-  }
-
-  const updateJsonArray = async (filePath: string) => {
-    try {
-      const raw = await fs.readFile(filePath, "utf8");
-      const parsed = JSON.parse(raw) as any[];
-      if (!Array.isArray(parsed) || !parsed.length) return;
-      let changed = false;
-      const updated = parsed.map((row) => {
-        if (row?.workspaceId && legacyIds.includes(row.workspaceId)) {
-          changed = true;
-          return { ...row, workspaceId: workspace.workspaceId };
-        }
-        return row;
-      });
-      if (changed) {
-        await fs.writeFile(filePath, JSON.stringify(updated, null, 2), "utf8");
-      }
-    } catch {
-      /* ignore */
-    }
-  };
-  await updateJsonArray(path.join(workspace.workspaceRoot, ".mcoda", "command_runs.json"));
-  await updateJsonArray(path.join(workspace.workspaceRoot, ".mcoda", "token_usage.json"));
-};
-
-export class WorkspaceResolver {
-  static async resolveWorkspace(input: { cwd?: string; explicitWorkspace?: string }): Promise<WorkspaceResolution> {
-    const cwd = path.resolve(input.cwd ?? process.cwd());
-    let explicit = input.explicitWorkspace;
-    let explicitPath: string | undefined;
-    if (explicit) {
-      const candidatePath = path.resolve(explicit);
-      if (await fileExists(candidatePath)) {
-        explicitPath = candidatePath;
-      } else if (await fileExists(path.join(candidatePath, ".mcoda"))) {
-        explicitPath = candidatePath;
-      } else if (looksLikeWorkspaceId(explicit)) {
-        throw new Error(
-          `Workspace id ${explicit} not recognized. Workspace registry lookups are not yet supported; pass a workspace path instead.`,
-        );
-      } else {
-        throw new Error(`Workspace path ${explicit} not found`);
-      }
-    }
-
-    const fromMarker = await findWorkspaceMarker(explicitPath ?? cwd);
-    const gitRoot = await findGitRoot(explicitPath ?? cwd);
-    const workspaceRoot = explicitPath ?? fromMarker ?? gitRoot ?? cwd;
-    const mcodaDir = path.join(workspaceRoot, ".mcoda");
-    await PathHelper.ensureDir(mcodaDir);
-    await ensureGitignore(workspaceRoot);
-    const existingIdentity = await readWorkspaceIdentity(mcodaDir);
-    let identity: WorkspaceIdentity;
-    let legacyIds: string[] = [];
-    if (existingIdentity) {
-      const existingLegacy = new Set<string>(existingIdentity.legacyIds ?? []);
-      let updatedIdentity = false;
-      legacyIds = [...(existingIdentity.legacyIds ?? [])];
-      if (existingIdentity.id && existingIdentity.id !== workspaceRoot) {
-        legacyIds.push(workspaceRoot);
-        updatedIdentity = true;
-      }
-      if (!looksLikeWorkspaceId(existingIdentity.id)) {
-        legacyIds.push(existingIdentity.id);
-        identity = {
-          ...existingIdentity,
-          id: randomUUID(),
-          legacyIds: Array.from(new Set(legacyIds)),
-        };
-        await writeWorkspaceIdentity(mcodaDir, identity);
-      } else {
-        identity = {
-          ...existingIdentity,
-          legacyIds: Array.from(new Set(legacyIds)),
-        };
-        if ((identity.legacyIds?.length ?? 0) !== existingLegacy.size) {
-          updatedIdentity = true;
-        }
-        if (updatedIdentity) {
-          await writeWorkspaceIdentity(mcodaDir, identity);
-        }
-      }
-    } else {
-      identity = {
-        id: randomUUID(),
-        name: path.basename(workspaceRoot),
-        createdAt: new Date().toISOString(),
-        legacyIds: [workspaceRoot],
-      };
-      await writeWorkspaceIdentity(mcodaDir, identity);
-    }
-    const legacyWorkspaceIds = Array.from(new Set([...(identity.legacyIds ?? []), workspaceRoot].filter(Boolean)));
-    const config = await readWorkspaceConfig(mcodaDir);
-    const resolution: WorkspaceResolution = {
-      workspaceRoot,
-      workspaceId: identity.id,
-      id: identity.id,
-      legacyWorkspaceIds,
-      mcodaDir,
-      workspaceDbPath: PathHelper.getWorkspaceDbPath(workspaceRoot),
-      globalDbPath: PathHelper.getGlobalDbPath(),
-      config,
-    };
-    // Best-effort migration of workspace_id columns and JSON logs from legacy IDs.
-    await migrateWorkspaceDbIds(resolution, legacyWorkspaceIds.filter((id) => id !== identity.id));
-    return resolution;
-  }
-}

package/packages/core/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "rootDir": "src",
-    "outDir": "dist",
-    "declaration": true,
-    "declarationMap": true,
-    "paths": {
-      "@mcoda/shared": ["packages/shared/dist/index.d.ts"],
-      "@mcoda/shared/*": ["packages/shared/dist/*"],
-      "@mcoda/db": ["packages/db/dist/index.d.ts"],
-      "@mcoda/db/*": ["packages/db/dist/*"],
-      "@mcoda/agents": ["packages/agents/dist/index.d.ts"],
-      "@mcoda/agents/*": ["packages/agents/dist/*"],
-      "@mcoda/integrations": ["packages/integrations/dist/index.d.ts"],
-      "@mcoda/integrations/*": ["packages/integrations/dist/*"]
-    }
-  },
-  "include": ["src"]
-}

package/packages/db/CHANGELOG.md

@@ -1,7 +0,0 @@
-# Changelog
-
-## Unreleased
-- Initial public packaging for @mcoda/db.
-
-## 0.1.2
-- Initial release.

package/packages/db/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 bekir dag
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/packages/db/README.md

@@ -1,9 +0,0 @@
-# @mcoda/db
-
-SQLite-backed storage layer for mcoda.
-
-## Usage
-This package is primarily an internal dependency of `mcoda`.
-
-## License
-MIT - see `LICENSE`.

package/packages/db/package.json

@@ -1,42 +0,0 @@
-{
-  "name": "@mcoda/db",
-  "version": "0.1.2",
-  "description": "SQLite-backed storage layer for mcoda.",
-  "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "files": [
-    "dist",
-    "!dist/**/__tests__/**",
-    "!dist/**/*.test.*",
-    "README.md",
-    "CHANGELOG.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "lint": "echo \"lint not configured\"",
-    "test": "pnpm run build && node ../../scripts/run-node-tests.js dist"
-  },
-  "engines": {
-    "node": ">=20"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/bekirdag/mcoda.git"
-  },
-  "bugs": {
-    "url": "https://github.com/bekirdag/mcoda/issues"
-  },
-  "homepage": "https://github.com/bekirdag/mcoda#readme",
-  "license": "MIT",
-  "author": "bekir dag",
-  "publishConfig": {
-    "access": "public"
-  },
-  "dependencies": {
-    "@mcoda/shared": "workspace:*",
-    "sqlite": "^5.1.1",
-    "sqlite3": "^5.1.7"
-  }
-}

package/packages/db/src/__tests__/GlobalRepository.test.ts

@@ -1,109 +0,0 @@
-import { strict as assert } from "node:assert";
-import { test, beforeEach, afterEach } from "node:test";
-import os from "node:os";
-import path from "node:path";
-import fs from "node:fs";
-import { Connection } from "../sqlite/connection.js";
-import { GlobalMigrations } from "../migrations/global/GlobalMigrations.js";
-import { GlobalRepository } from "../repositories/global/GlobalRepository.js";
-
-let repo: GlobalRepository;
-let dbPath: string;
-
-beforeEach(async () => {
-  dbPath = path.join(os.tmpdir(), `mcoda-agent-${Date.now()}-${Math.random()}.db`);
-  const conn = await Connection.open(dbPath);
-  await GlobalMigrations.run(conn.db);
-  repo = new GlobalRepository(conn.db, conn);
-});
-
-afterEach(async () => {
-  await repo.close();
-  await fs.promises.unlink(dbPath).catch(() => {});
-});
-
-test("creates, updates, and deletes an agent with capabilities and prompts", async () => {
-  const created = await repo.createAgent({
-    slug: "test-agent",
-    adapter: "openai-api",
-    defaultModel: "gpt-4o",
-    capabilities: ["plan", "code_write"],
-    models: [
-      { agentId: "ignored", modelName: "gpt-4o", isDefault: true },
-      { agentId: "ignored", modelName: "gpt-4.1-mini", isDefault: false },
-    ],
-    prompts: { jobPrompt: "job", characterPrompt: "character" },
-  });
-  assert.equal(created.slug, "test-agent");
-
-  const fetched = await repo.getAgentBySlug("test-agent");
-  assert.ok(fetched);
-  assert.equal(fetched?.defaultModel, "gpt-4o");
-
-  const capabilities = await repo.getAgentCapabilities(created.id);
-  assert.deepEqual(capabilities.sort(), ["code_write", "plan"].sort());
-
-  const prompts = await repo.getAgentPrompts(created.id);
-  assert.equal(prompts?.jobPrompt, "job");
-
-  const models = await repo.getAgentModels(created.id);
-  assert.equal(models.length, 2);
-  assert.equal(models[0]?.agentId, created.id);
-
-  await repo.updateAgent(created.id, { defaultModel: "gpt-4.1-mini" });
-  const updated = await repo.getAgentById(created.id);
-  assert.equal(updated?.defaultModel, "gpt-4.1-mini");
-
-  await repo.deleteAgent(created.id);
-  const afterDelete = await repo.getAgentById(created.id);
-  assert.equal(afterDelete, undefined);
-});
-
-test("stores auth metadata and health records", async () => {
-  const created = await repo.createAgent({
-    slug: "auth-agent",
-    adapter: "openai-api",
-  });
-  await repo.setAgentAuth(created.id, "encrypted-secret");
-  const auth = await repo.getAgentAuthMetadata(created.id);
-  assert.equal(auth.configured, true);
-
-  const health = {
-    agentId: created.id,
-    status: "healthy" as const,
-    lastCheckedAt: new Date().toISOString(),
-    latencyMs: 5,
-  };
-  await repo.setAgentHealth(health);
-  const storedHealth = await repo.getAgentHealth(created.id);
-  assert.equal(storedHealth?.status, "healthy");
-});
-
-test("records command runs and token usage", async () => {
-  const created = await repo.createAgent({ slug: "telemetry-agent", adapter: "codex-cli" });
-  const run = await repo.createCommandRun({
-    commandName: "agent.test",
-    startedAt: new Date().toISOString(),
-    status: "running",
-    payload: { agentId: created.id },
-  });
-  await repo.recordTokenUsage({
-    agentId: created.id,
-    commandRunId: run.id,
-    modelName: "test-model",
-    tokensPrompt: 0,
-    tokensCompletion: 0,
-    tokensTotal: 0,
-    timestamp: new Date().toISOString(),
-    metadata: { reason: "test" },
-  });
-  await repo.completeCommandRun(run.id, {
-    status: "succeeded",
-    completedAt: new Date().toISOString(),
-  });
-
-  const runs = await (repo as any).db.all("SELECT command_name FROM command_runs WHERE id = ?", run.id);
-  assert.equal(runs.length, 1);
-  const usage = await (repo as any).db.all("SELECT agent_id FROM token_usage WHERE command_run_id = ?", run.id);
-  assert.equal(usage.length, 1);
-});

package/packages/db/src/__tests__/SchemaAlignment.test.ts

@@ -1,80 +0,0 @@
-import assert from "node:assert/strict";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { test } from "node:test";
-import { Connection } from "../sqlite/connection.js";
-import { GlobalMigrations } from "../migrations/global/GlobalMigrations.js";
-import { WorkspaceMigrations } from "../migrations/workspace/WorkspaceMigrations.js";
-
-const AGENT_TABLES = [
-  "agents",
-  "agent_auth",
-  "agent_capabilities",
-  "agent_prompts",
-  "agent_health",
-  "agent_models",
-  "workspace_defaults",
-];
-
-const collectTables = async (db: any): Promise<Set<string>> => {
-  const rows = (await db.all("SELECT name FROM sqlite_master WHERE type = 'table'")) as Array<{
-    name?: string;
-  }>;
-  return new Set(rows.map((r) => (r.name ?? "").toString()));
-};
-
-const readOpenapiTables = async (): Promise<Set<string>> => {
-  const here = path.dirname(fileURLToPath(import.meta.url));
-  const openapiPath = path.resolve(here, "../../../../openapi/mcoda.yaml");
-  const content = await fs.readFile(openapiPath, "utf8");
-  const matches = [...content.matchAll(/x-mcoda-db-table:\s*([A-Za-z0-9_]+)/g)];
-  return new Set(matches.map((m) => m[1]));
-};
-
-const withTempDb = async (fn: (dbPath: string) => Promise<void>): Promise<void> => {
-  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "mcoda-schema-"));
-  try {
-    const dbPath = path.join(dir, "mcoda.db");
-    await fn(dbPath);
-  } finally {
-    await fs.rm(dir, { recursive: true, force: true });
-  }
-};
-
-test("agent-related x-mcoda-db-table entries exist in global DB and not in workspace DB", async () => {
-  const tablesFromOpenapi = await readOpenapiTables();
-  for (const table of AGENT_TABLES) {
-    assert.ok(
-      tablesFromOpenapi.has(table),
-      `OpenAPI x-mcoda-db-table is missing expected table ${table}`,
-    );
-  }
-
-  await withTempDb(async (dbPath) => {
-    const globalConn = await Connection.open(dbPath);
-    await GlobalMigrations.run(globalConn.db);
-    const globalTables = await collectTables(globalConn.db);
-    await globalConn.close();
-
-    AGENT_TABLES.forEach((table) => {
-      assert.ok(globalTables.has(table), `Global DB missing table ${table}`);
-    });
-  });
-
-  await withTempDb(async (dbPath) => {
-    const workspaceConn = await Connection.open(dbPath);
-    await WorkspaceMigrations.run(workspaceConn.db);
-    const workspaceTables = await collectTables(workspaceConn.db);
-    await workspaceConn.close();
-
-    AGENT_TABLES.forEach((table) => {
-      assert.equal(
-        workspaceTables.has(table),
-        false,
-        `Workspace DB should not contain agent table ${table}`,
-      );
-    });
-  });
-});

package/packages/db/src/__tests__/WorkspaceRepository.test.ts

@@ -1,19 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { WorkspaceRepository } from "../repositories/workspace/WorkspaceRepository.js";
-
-test("WorkspaceRepository createProjectIfMissing is idempotent", async () => {
-  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "mcoda-db-"));
-  const repo = await WorkspaceRepository.create(dir);
-  try {
-    const first = await repo.createProjectIfMissing({ key: "proj", name: "Project" });
-    const second = await repo.createProjectIfMissing({ key: "proj", name: "Project" });
-    assert.equal(first.id, second.id);
-  } finally {
-    await repo.close();
-    await fs.rm(dir, { recursive: true, force: true });
-  }
-});

package/packages/db/src/index.d.ts

@@ -1,6 +0,0 @@
-export * from "./sqlite/connection.js";
-export * from "./migrations/global/GlobalMigrations.js";
-export * from "./migrations/workspace/WorkspaceMigrations.js";
-export * from "./repositories/global/GlobalRepository.js";
-export * from "./repositories/workspace/WorkspaceRepository.js";
-//# sourceMappingURL=index.d.ts.map

package/packages/db/src/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,yCAAyC,CAAC;AACxD,cAAc,+CAA+C,CAAC;AAC9D,cAAc,2CAA2C,CAAC;AAC1D,cAAc,iDAAiD,CAAC"}

package/packages/db/src/index.js

@@ -1,5 +0,0 @@
-export * from "./sqlite/connection.js";
-export * from "./migrations/global/GlobalMigrations.js";
-export * from "./migrations/workspace/WorkspaceMigrations.js";
-export * from "./repositories/global/GlobalRepository.js";
-export * from "./repositories/workspace/WorkspaceRepository.js";

package/packages/db/src/index.ts

@@ -1,6 +0,0 @@
-export * from "./sqlite/connection.js";
-export * from "./migrations/global/GlobalMigrations.js";
-export * from "./migrations/workspace/WorkspaceMigrations.js";
-export * from "./repositories/global/GlobalRepository.js";
-export * from "./repositories/workspace/WorkspaceRepository.js";
-export type { Database } from "sqlite";

package/packages/db/src/migrations/global/GlobalMigrations.d.ts

@@ -1,9 +0,0 @@
-import { Database } from "sqlite";
-/**
- * Global database migrations for ~/.mcoda/mcoda.db.
- * Only includes tables required for the agent registry and routing defaults.
- */
-export declare class GlobalMigrations {
-    static run(db: Database): Promise<void>;
-}
-//# sourceMappingURL=GlobalMigrations.d.ts.map

package/packages/db/src/migrations/global/GlobalMigrations.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"GlobalMigrations.d.ts","sourceRoot":"","sources":["GlobalMigrations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAElC;;;GAGG;AACH,qBAAa,gBAAgB;WACd,GAAG,CAAC,EAAE,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;CA8D9C"}

package/packages/db/src/migrations/global/GlobalMigrations.js

@@ -1,68 +0,0 @@
-/**
- * Global database migrations for ~/.mcoda/mcoda.db.
- * Only includes tables required for the agent registry and routing defaults.
- */
-export class GlobalMigrations {
-    static async run(db) {
-        await db.exec(`
-      CREATE TABLE IF NOT EXISTS agents (
-        id TEXT PRIMARY KEY,
-        slug TEXT UNIQUE NOT NULL,
-        adapter TEXT NOT NULL,
-        default_model TEXT,
-        config_json TEXT,
-        created_at TEXT NOT NULL,
-        updated_at TEXT NOT NULL
-      );
-
-      CREATE TABLE IF NOT EXISTS agent_auth (
-        agent_id TEXT PRIMARY KEY REFERENCES agents(id) ON DELETE CASCADE,
-        encrypted_secret TEXT NOT NULL,
-        last_verified_at TEXT,
-        created_at TEXT NOT NULL,
-        updated_at TEXT NOT NULL
-      );
-
-      CREATE TABLE IF NOT EXISTS agent_capabilities (
-        agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
-        capability TEXT NOT NULL,
-        PRIMARY KEY (agent_id, capability)
-      );
-
-      CREATE TABLE IF NOT EXISTS agent_prompts (
-        agent_id TEXT PRIMARY KEY REFERENCES agents(id) ON DELETE CASCADE,
-        job_prompt TEXT,
-        character_prompt TEXT,
-        command_prompts_json TEXT,
-        job_path TEXT,
-        character_path TEXT,
-        created_at TEXT NOT NULL,
-        updated_at TEXT NOT NULL
-      );
-
-      CREATE TABLE IF NOT EXISTS agent_health (
-        agent_id TEXT PRIMARY KEY REFERENCES agents(id) ON DELETE CASCADE,
-        status TEXT NOT NULL,
-        last_checked_at TEXT NOT NULL,
-        latency_ms INTEGER,
-        details_json TEXT
-      );
-
-      CREATE TABLE IF NOT EXISTS agent_models (
-        agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
-        model_name TEXT NOT NULL,
-        is_default INTEGER DEFAULT 0,
-        config_json TEXT,
-        PRIMARY KEY (agent_id, model_name)
-      );
-
-      CREATE TABLE IF NOT EXISTS workspace_defaults (
-        workspace_id TEXT NOT NULL,
-        command_name TEXT NOT NULL,
-        agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
-        updated_at TEXT NOT NULL,
-        PRIMARY KEY (workspace_id, command_name)
-      );
-    `);
-    }
-}