@geraldmaron/construct 1.0.23 → 1.0.24

package/lib/strategy-store.mjs

@@ -6,23 +6,19 @@
  * Strategy documents are NEVER auto-updated from ingested documents — they require
  * an explicit writeStrategy() call from a privileged caller.
  *
- * In team/enterprise mode Postgres is the secondary store (best-effort). Each scope
- * is stored as a separate row whose content is prefixed with `scope:{name}\n` so we
- * can store and retrieve scopes without adding a new column to the existing schema.
+ * Construct now uses embedded LanceDB for vectors only; strategy remains
+ * filesystem-primary for simplicity and Git-backed collaboration.
  *
  * getStrategyDigest() / getStrategyDigestSync() return a compact block (≤ 500 tokens)
  * suitable for injection into agent prompts. getStrategyDigestSync() is the file-only
  * synchronous path required where await is not available (e.g. prompt assembly).
  */
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync } from 'node:fs';
 import { join, basename } from 'node:path';
 import { cxDir } from './paths.mjs';
-import { hasSqlStore } from './storage/sql-store.mjs';
-import { createSqlClient } from './storage/backend.mjs';
 
 const VALID_SCOPES = ['product', 'technical', 'gtm', 'platform'];
-const SCOPE_PREFIX = 'scope:';
 
 // ── Path helpers ──────────────────────────────────────────────────────────────
 
@@ -38,9 +34,6 @@ export function strategyFilePath(scope = 'product', env = process.env) {
 
 /**
  * Return scope names that have corresponding files in the strategy directory.
- *
- * @param {object} [env]
- * @returns {string[]}
  */
 export function listStrategyScopes(env = process.env) {
   const dir = strategyDir(env);
@@ -57,315 +50,71 @@ export function listStrategyScopes(env = process.env) {
 // ── Read helpers ──────────────────────────────────────────────────────────────
 
 /**
- * Read one strategy scope from Postgres (primary) or file (fallback).
- *
- * @param {string} [scope]
- * @param {object} [env]
- * @returns {Promise<{ content: string, version: number, updatedAt: string, source: 'postgres'|'file'|'none', scope: string }>}
+ * Read one strategy scope from file.
  */
 export async function readStrategy(scope = 'product', env = process.env) {
-  if (hasSqlStore(env)) {
-    const client = createSqlClient(env);
-    try {
-      const project = env.CX_PROJECT || 'default';
-      const prefix = `${SCOPE_PREFIX}${scope}\n`;
-
-      // Rows stored with the scope prefix — match on content prefix
-      const rows = await client`
-        select content, version, updated_at
-        from construct_strategy
-        where project = ${project}
-          and content like ${prefix + '%'}
-        order by version desc
-        limit 1
-      `;
-
-      if (rows.length > 0) {
-        const row = rows[0];
-        return {
-          content: row.content.startsWith(prefix) ? row.content.slice(prefix.length) : row.content,
-          version: row.version,
-          updatedAt: row.updated_at instanceof Date ? row.updated_at.toISOString() : String(row.updated_at),
-          source: 'postgres',
-          scope,
-        };
-      }
-    } catch {
-      // Postgres unavailable — fall through to file
-    } finally {
-      if (client) await client.end({ timeout: 5 }).catch(() => {});
-    }
-  }
-
   const filePath = strategyFilePath(scope, env);
-  if (existsSync(filePath)) {
+  if (!existsSync(filePath)) {
+    return { content: '', version: 0, updatedAt: null, source: 'none', scope };
+  }
+  try {
     const content = readFileSync(filePath, 'utf8');
-    return { content, version: 1, updatedAt: new Date().toISOString(), source: 'file', scope };
+    const stat = statSync(filePath);
+    return {
+      content,
+      version: 1,
+      updatedAt: stat.mtime.toISOString(),
+      source: 'file',
+      scope,
+    };
+  } catch {
+    return { content: '', version: 0, updatedAt: null, source: 'none', scope };
   }
-
-  return { content: '', version: 0, updatedAt: new Date().toISOString(), source: 'none', scope };
 }
 
 /**
- * Read all present strategy scopes.
- *
- * When Postgres is available it reads all rows for the project and parses scope
- * from the prefix. Files are used as the fallback or supplement for scopes that
- * have no Postgres row.
- *
- * @param {object} [env]
- * @returns {Promise<Map<string, { content: string, version: number, updatedAt: string, source: string }>>}
+ * Read all strategy scopes into a Map.
  */
 export async function readAllStrategies(env = process.env) {
   const result = new Map();
-
-  if (hasSqlStore(env)) {
-    const client = createSqlClient(env);
-    try {
-      const project = env.CX_PROJECT || 'default';
-
-      // Fetch all rows — latest version per scope
-      const rows = await client`
-        select distinct on (
-          substring(content from 1 for position(E'\n' in content))
-        ) content, version, updated_at
-        from construct_strategy
-        where project = ${project}
-          and content like ${SCOPE_PREFIX + '%'}
-        order by
-          substring(content from 1 for position(E'\n' in content)),
-          version desc
-      `;
-
-      for (const row of rows) {
-        const firstNewline = row.content.indexOf('\n');
-        if (firstNewline === -1) continue;
-        const header = row.content.slice(0, firstNewline);
-        if (!header.startsWith(SCOPE_PREFIX)) continue;
-        const rowScope = header.slice(SCOPE_PREFIX.length);
-        const content = row.content.slice(firstNewline + 1);
-        result.set(rowScope, {
-          content,
-          version: row.version,
-          updatedAt: row.updated_at instanceof Date ? row.updated_at.toISOString() : String(row.updated_at),
-          source: 'postgres',
-        });
-      }
-    } catch {
-      // Fall through to file-based reads
-    } finally {
-      if (client) await client.end({ timeout: 5 }).catch(() => {});
-    }
-  }
-
-  // Supplement / replace with file-based reads for any scope present on disk
-  const fileScopes = listStrategyScopes(env);
-  for (const fileScope of fileScopes) {
-    if (result.has(fileScope)) continue;
-    const filePath = strategyFilePath(fileScope, env);
-    try {
-      const content = readFileSync(filePath, 'utf8');
-      result.set(fileScope, {
-        content,
-        version: 1,
-        updatedAt: new Date().toISOString(),
-        source: 'file',
-      });
-    } catch {
-      // Skip unreadable files
-    }
+  const scopes = listStrategyScopes(env);
+  for (const scope of scopes) {
+    const data = await readStrategy(scope, env);
+    if (data.source !== 'none') result.set(scope, data);
   }
-
   return result;
 }
 
-// ── Digest helpers ────────────────────────────────────────────────────────────
-
-/**
- * Parse markdown into sections split on ## headers.
- *
- * @param {string} content
- * @returns {Array<{ header: string, body: string }>}
- */
-function parseSections(content) {
-  const lines = content.split('\n');
-  const sections = [];
-  let current = null;
-
-  for (const line of lines) {
-    if (line.startsWith('## ')) {
-      if (current) sections.push(current);
-      current = { header: line.slice(3).trim(), body: '' };
-    } else if (current) {
-      current.body += line + '\n';
-    }
-  }
-  if (current) sections.push(current);
-  return sections;
-}
-
-/**
- * Truncate a body to the first N sentences.
- *
- * @param {string} body
- * @param {number} maxSentences
- * @returns {string}
- */
-function firstSentences(body, maxSentences = 2) {
-  const trimmed = body.trim();
-  if (!trimmed) return '';
-  const sentences = trimmed.match(/[^.!?\n]+[.!?\n]+/g) || [trimmed];
-  return sentences.slice(0, maxSentences).join(' ').trim();
-}
-
-/**
- * Build a compact markdown block from a single scope's content.
- *
- * @param {string} scopeName
- * @param {string} content
- * @param {number} charBudget — remaining character budget; mutated by reference via returned delta
- * @returns {{ text: string, charsUsed: number }}
- */
-function buildScopeBlock(scopeName, content, charBudget) {
-  const sections = parseSections(content);
-  if (!sections.length) return { text: '', charsUsed: 0 };
-
-  const lines = [`### ${scopeName}`];
-  let used = scopeName.length + 5;
-
-  for (const { header, body } of sections) {
-    if (used >= charBudget) break;
-    const excerpt = firstSentences(body, 2);
-    const line = excerpt ? `**${header}:** ${excerpt}` : `**${header}**`;
-    lines.push(line);
-    used += line.length + 1;
-  }
-
-  const text = lines.join('\n');
-  return { text, charsUsed: used };
-}
-
 /**
- * Return a compact strategy digest (≤ 500 tokens) for agent prompt injection.
- *
- * Reads all present scopes asynchronously. Returns empty string when no scopes exist.
- *
- * @param {object} [env]
- * @returns {Promise<string>}
+ * Synchronous digest for prompt assembly.
  */
-export async function getStrategyDigest(env = process.env) {
+export function getStrategyDigestSync(scope = 'product', env = process.env) {
+  const filePath = strategyFilePath(scope, env);
+  if (!existsSync(filePath)) return '';
   try {
-    const all = await readAllStrategies(env);
-    if (!all.size) return '';
-
-    const TOKEN_LIMIT = 500;
-    let charBudget = TOKEN_LIMIT * 4;
-    const parts = ['## Active strategy'];
-
-    for (const [scopeName, { content }] of all) {
-      if (!content) continue;
-      const { text, charsUsed } = buildScopeBlock(scopeName, content, charBudget);
-      if (text) {
-        parts.push(text);
-        charBudget -= charsUsed;
-      }
-      if (charBudget <= 0) break;
-    }
-
-    return parts.length > 1 ? parts.join('\n') : '';
+    const content = readFileSync(filePath, 'utf8');
+    return content.trim().slice(0, 2000); // approx 500 tokens
   } catch {
     return '';
   }
 }
 
 /**
- * Synchronous file-only strategy digest for prompt-composer.js.
- *
- * Reads all .md files present in the strategy directory directly. Never reads
- * Postgres. Returns empty string when the directory is absent or empty.
- *
- * @param {object} [env]
- * @returns {string}
+ * Async digest for general use.
  */
-export function getStrategyDigestSync(env = process.env) {
-  try {
-    const dir = strategyDir(env);
-    if (!existsSync(dir)) return '';
-
-    const files = readdirSync(dir).filter((f) => f.endsWith('.md'));
-    if (!files.length) return '';
-
-    const TOKEN_LIMIT = 500;
-    let charBudget = TOKEN_LIMIT * 4;
-    const parts = ['## Active strategy'];
-
-    for (const file of files) {
-      if (charBudget <= 0) break;
-      const scopeName = basename(file, '.md');
-      let content;
-      try {
-        content = readFileSync(join(dir, file), 'utf8');
-      } catch {
-        continue;
-      }
-      if (!content) continue;
-      const { text, charsUsed } = buildScopeBlock(scopeName, content, charBudget);
-      if (text) {
-        parts.push(text);
-        charBudget -= charsUsed;
-      }
-    }
-
-    return parts.length > 1 ? parts.join('\n') : '';
-  } catch {
-    return '';
-  }
+export async function getStrategyDigest(scope = 'product', env = process.env) {
+  const data = await readStrategy(scope, env);
+  return data.content.trim().slice(0, 2000);
 }
 
-// ── Write ─────────────────────────────────────────────────────────────────────
+// ── Write helpers ─────────────────────────────────────────────────────────────
 
 /**
- * Write a strategy scope to file (always) and Postgres (best-effort if available).
- *
- * The scope parameter defaults to 'product'. When writing to Postgres the content
- * is prefixed with `scope:{name}\n` to allow per-scope storage without a schema change.
- *
- * @param {string} content
- * @param {string} [scope]
- * @param {object} [opts]
- * @param {string} [opts.updatedBy]
- * @param {object} [opts.env]
+ * Write a strategy scope to file.
  */
 export async function writeStrategy(content, scope = 'product', { updatedBy, env = process.env } = {}) {
   const filePath = strategyFilePath(scope, env);
   const dir = strategyDir(env);
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
   writeFileSync(filePath, content, 'utf8');
-
-  if (!hasSqlStore(env)) return;
-
-  const client = createSqlClient(env);
-  try {
-    const project = env.CX_PROJECT || 'default';
-    const scopedContent = `${SCOPE_PREFIX}${scope}\n${content}`;
-    const prefix = `${SCOPE_PREFIX}${scope}\n`;
-
-    const existing = await client`
-      select version from construct_strategy
-      where project = ${project}
-        and content like ${prefix + '%'}
-      order by version desc
-      limit 1
-    `;
-    const nextVersion = existing.length > 0 ? existing[0].version + 1 : 1;
-
-    await client`
-      insert into construct_strategy (project, content, version, updated_by)
-      values (${project}, ${scopedContent}, ${nextVersion}, ${updatedBy ?? null})
-    `;
-  } catch {
-    // Best-effort Postgres write — file write already succeeded
-  } finally {
-    if (client) await client.end({ timeout: 5 }).catch(() => {});
-  }
 }

package/lib/worker/entrypoint.mjs

@@ -24,8 +24,7 @@
 
 import path from 'node:path';
 
-import { createSqlClient, closeSqlClient } from '../storage/backend.mjs';
-import { PostgresIntakeQueue } from '../intake/postgres-queue.mjs';
+import { createIntakeQueue } from '../intake/queue.mjs';
 import { FilesystemTaskGraphStore } from '../task-graph/store.mjs';
 import { runJob } from './run.mjs';
 import { evidenceFromJobResult, recordEvidence, blockedPacket } from './evidence.mjs';
@@ -167,7 +166,6 @@ export async function runWorkerLoop({
   rootDir,
   workspace,
   project,
-  sql,
   queue: injectedQueue = null,
   store: injectedStore = null,
   pollIntervalMs = DEFAULT_POLL_INTERVAL_MS,
@@ -178,10 +176,9 @@ export async function runWorkerLoop({
 } = {}) {
   if (!project) throw new Error('runWorkerLoop: project is required');
   if (!workspace) throw new Error('runWorkerLoop: workspace is required');
-  if (!injectedQueue && !sql) throw new Error('runWorkerLoop: sql client (or injected queue) is required');
 
   const workerName = readWorkerName();
-  const queue = injectedQueue || new PostgresIntakeQueue({ sql, project });
+  const queue = injectedQueue || createIntakeQueue(rootDir, process.env, { project });
   const store = injectedStore || new FilesystemTaskGraphStore(rootDir);
 
   let processed = 0;
@@ -223,19 +220,14 @@ if (invokedDirectly) {
   const pollIntervalMs = Number(args['poll-interval-ms'] || DEFAULT_POLL_INTERVAL_MS);
   const idleTimeoutSeconds = Number(args['idle-timeout-seconds'] || DEFAULT_IDLE_TIMEOUT_SECONDS);
 
-  const sql = createSqlClient(process.env);
-  if (!sql) {
-    process.stderr.write('[worker] DATABASE_URL is required for the worker entrypoint.\n');
-    process.exit(78); // EX_CONFIG
-  }
-
   try {
     const summary = await runWorkerLoop({
-      rootDir, workspace, project, sql, pollIntervalMs, idleTimeoutSeconds,
+      rootDir, workspace, project, pollIntervalMs, idleTimeoutSeconds,
     });
     process.stdout.write(`[worker] exiting after idle timeout — processed=${summary.processed} skipped=${summary.skipped} worker=${summary.workerName}\n`);
     process.exit(0);
-  } finally {
-    await closeSqlClient(sql);
+  } catch (err) {
+    process.stderr.write(`[worker] failed: ${err.stack}\n`);
+    process.exit(1);
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geraldmaron/construct",
-  "version": "1.0.23",
+  "version": "1.0.24",
   "type": "module",
   "packageManager": "npm@11.5.1",
   "description": "Construct — agent orchestration layer for OpenCode, Claude Code, and other coding surfaces",
@@ -80,16 +80,17 @@
     "postinstall": "node ./bin/construct-postinstall.mjs"
   },
   "dependencies": {
+    "@lancedb/lancedb": "^0.30.0",
     "@modelcontextprotocol/sdk": "^1.12.0",
-    "js-yaml": "^4.2.0",
-    "postgres": "^3.4.9"
+    "apache-arrow": "^18.1.0",
+    "js-yaml": "^4.2.0"
   },
   "optionalDependencies": {
     "@huggingface/transformers": "^4.2.0",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/core": "^2.7.1",
     "@opentelemetry/exporter-trace-otlp-http": "^0.218.0",
-    "@opentelemetry/resources": "^1.25.0",
+    "@opentelemetry/resources": "^2.7.1",
     "@opentelemetry/sdk-trace-node": "^1.25.0",
     "@opentelemetry/semantic-conventions": "^1.25.0"
   },
@@ -99,7 +100,7 @@
   "devDependencies": {
     "@eslint/js": "^9.39.4",
     "c8": "^11.0.0",
-    "eslint": "^9.39.4",
+    "eslint": "^10.4.1",
     "globals": "^17.6.0"
   }
 }

package/platforms/claude/settings.template.json

@@ -547,13 +547,6 @@
     "memory": {
       "type": "http",
       "url": "http://127.0.0.1:8765/"
-    },
-    "playwright": {
-      "command": "npx",
-      "args": [
-        "-y",
-        "@playwright/mcp@latest"
-      ]
     }
   }
 }

package/scripts/sync-specialists.mjs

@@ -800,6 +800,50 @@ function makeHooksPortable(hooksJson) {
   return JSON.stringify(walk(hooksJson));
 }
 
+const GLOBAL_CLAUDE_HOOK_IDS = new Set([
+  'pre:bash:block-no-verify',
+  'pre:bash:guard-dangerous',
+  'pre:edit:config-protection',
+  'pre:edit-guard',
+  'post:edit:json-validate',
+  'post:edit:scan-secrets',
+]);
+
+const GLOBAL_CLAUDE_MCP_IDS = new Set([
+  'context7',
+]);
+
+function filterGlobalClaudeHooks(hooksJson) {
+  const filtered = {};
+  for (const [event, groups] of Object.entries(hooksJson ?? {})) {
+    const kept = groups.filter((group) => GLOBAL_CLAUDE_HOOK_IDS.has(group.id));
+    if (kept.length > 0) filtered[event] = kept;
+  }
+  return filtered;
+}
+
+function syncGlobalClaudeMcpServers(settings, registryMcp) {
+  settings.mcpServers ??= {};
+  for (const id of Object.keys(settings.mcpServers)) {
+    if (id in registryMcp && !GLOBAL_CLAUDE_MCP_IDS.has(id)) {
+      delete settings.mcpServers[id];
+    }
+  }
+
+  for (const [id, mcpDef] of Object.entries(registryMcp)) {
+    if (!GLOBAL_CLAUDE_MCP_IDS.has(id)) continue;
+    const existingEntry = settings.mcpServers[id];
+    const existing = JSON.stringify(existingEntry ?? "");
+    const hasPlaceholder = existing.includes("__");
+    const hasFloatingVersion = existing.includes("@latest");
+    const registryWantsCommand = !mcpDef.type && Array.isArray(mcpDef.args);
+    const existingIsRemote = existingEntry && (existingEntry.type === 'http' || existingEntry.type === 'remote');
+    const transportMismatch = registryWantsCommand && existingIsRemote;
+    if (existingEntry && !hasPlaceholder && !hasFloatingVersion && !transportMismatch) continue;
+    settings.mcpServers[id] = buildClaudeMcpEntry(id, mcpDef, process.env);
+  }
+}
+
 /**
  * Materialise a project-local `.claude/settings.json` from the home template,
  * with hook commands rewritten to be path-relative to whatever Construct
@@ -908,23 +952,13 @@ ${personaList}
           const constructReal = (() => {
             try { return fs.realpathSync(path.join(home, ".construct")); } catch { return path.join(home, ".construct"); }
           })();
-          const hookStr = JSON.stringify(template.hooks)
+          const hookStr = JSON.stringify(filterGlobalClaudeHooks(template.hooks))
             .replace(/\$HOME\/\.construct/g, constructReal.replace(/\\/g, "/"));
           settings.hooks = JSON.parse(hookStr);
         }
       }
-      if (!settings.mcpServers) settings.mcpServers = {};
       const registryMcp = registry.mcpServers ?? {};
-      for (const [id, mcpDef] of Object.entries(registryMcp)) {
-        const existingEntry = settings.mcpServers[id];
-        const existing = JSON.stringify(existingEntry ?? "");
-        const hasPlaceholder = existing.includes("__");
-        const registryWantsCommand = !mcpDef.type && Array.isArray(mcpDef.args);
-        const existingIsRemote = existingEntry && (existingEntry.type === 'http' || existingEntry.type === 'remote');
-        const transportMismatch = registryWantsCommand && existingIsRemote;
-        if (existingEntry && !hasPlaceholder && !transportMismatch) continue;
-        settings.mcpServers[id] = buildClaudeMcpEntry(id, mcpDef, process.env);
-      }
+      syncGlobalClaudeMcpServers(settings, registryMcp);
       if (!DRY_RUN) fs.writeFileSync(claudeSettingsPath, JSON.stringify(settings, null, 2) + "\n");
     }
   }

package/specialists/prompts/cx-qa.md

@@ -18,7 +18,7 @@ You have watched acceptance criteria pass tests that didn't actually test the ac
 **Role guidance**: call `get_skill("roles/qa")` before drafting.
 
 When the verification domain is clear, also load exactly one relevant overlay before drafting:
-- `roles/qa.web-ui` for UI flows, accessibility, responsive states, visual regression, keyboard behavior, and browser automation
+- `roles/qa.web-ui` for UI flows, accessibility, responsive states, visual regression, keyboard behavior, and browser automation. Live-browser automation (driving a real page, screenshots, click/keyboard flows) is not installed by default — opt in with `construct mcp add playwright` when a verification actually needs it.
 - `roles/qa.api-contract` for APIs, SDKs, status codes, error bodies, compatibility, and consumer-driven contracts
 - `roles/qa.data-pipeline` for ETL/ELT, data contracts, freshness, uniqueness, replay, backfills, and data quality checks
 - `roles/qa.ai-eval` for agents, prompts, model changes, retrieval, eval rubrics, golden traces, and promotion gates

package/specialists/registry.json

@@ -1467,14 +1467,6 @@
       ],
       "description": "Library and framework documentation lookup"
     },
-    "playwright": {
-      "command": "npx",
-      "args": [
-        "-y",
-        "@playwright/mcp@0.0.75"
-      ],
-      "description": "Browser automation and E2E testing"
-    },
     "github": {
       "type": "url",
       "url": "https://api.githubcopilot.com/mcp/",

package/templates/docs/construct_guide.md

@@ -67,7 +67,7 @@ The full list of personas lives in `.claude/agents/`. Run `construct list` to se
 
 Two scopes:
 
-**Per-project** (committed, shared with peers): edit `.claude/settings.json`. Construct owns the `hooks` block and a known set of `mcpServers` keys (memory, context7, playwright, github, sequential-thinking, construct-mcp); your additions are preserved on `npm install`. Other top-level keys are yours to control.
+**Per-project** (committed, shared with peers): edit `.claude/settings.json`. Construct owns the `hooks` block and a known set of `mcpServers` keys (memory, context7, github, sequential-thinking, construct-mcp); your additions — including opt-in MCPs like `playwright` (`construct mcp add playwright`) — are preserved on `npm install`. Other top-level keys are yours to control.
 
 **Per-machine** (private to you): edit `~/.construct/config.env`. This is where your API keys, consent flags, and local-service credentials live. Standard `KEY=value` format.
 

package/db/schema/001_init.sql

@@ -1,40 +0,0 @@
-create extension if not exists vector;
-
-create table if not exists construct_documents (
-  id text primary key,
-  project text not null,
-  kind text not null,
-  title text not null,
-  summary text,
-  body text not null,
-  source_path text,
-  tags jsonb not null default '[]'::jsonb,
-  content_hash text not null,
-  updated_at timestamptz not null default now(),
-  created_at timestamptz not null default now()
-);
-
-create index if not exists construct_documents_project_kind_idx on construct_documents (project, kind);
-create index if not exists construct_documents_content_hash_idx on construct_documents (content_hash);
-
-create table if not exists construct_embeddings (
-  document_id text primary key references construct_documents(id) on delete cascade,
-  model text not null,
-  embedding double precision[] not null,
-  content_hash text not null,
-  updated_at timestamptz not null default now(),
-  created_at timestamptz not null default now()
-);
-
-create index if not exists construct_embeddings_model_idx on construct_embeddings (model);
-
-create table if not exists construct_sync_runs (
-  id bigserial primary key,
-  project text not null,
-  source text not null,
-  documents_synced integer not null default 0,
-  embeddings_synced integer not null default 0,
-  status text not null,
-  note text,
-  created_at timestamptz not null default now()
-);