@geraldmaron/construct 1.0.3 → 1.0.5

package/lib/embed/conflict-detection.mjs

@@ -11,18 +11,33 @@
  *   2. Contradiction detection — new signal contradicts a documented decision
  *
  * Storage:
- *   ~/.cx/product-intel/artifact-index.json — cached artifact embeddings
+ *   ~/.cx/knowledge/reference/artifact-index.json — cached artifact embeddings
  *   Rebuilt on first use or when artifact file count changes.
  */
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync, renameSync } from 'node:fs';
 import { join } from 'node:path';
-import { homedir } from 'node:os';
 import { embed, cosineSimilarity, extractTextFromPacket } from './semantic.mjs';
 import { listArtifacts } from './artifact.mjs';
+import { cxDir } from '../paths.mjs';
+import { knowledgeReferenceStore } from '../knowledge/layout.mjs';
 
-const INDEX_DIR = join(homedir(), '.cx', 'product-intel');
-const INDEX_FILE = join(INDEX_DIR, 'artifact-index.json');
+function migrateLegacyIndex(indexFile, legacyFile) {
+  if (existsSync(indexFile) || !existsSync(legacyFile)) return;
+  mkdirSync(join(indexFile, '..'), { recursive: true });
+  try { renameSync(legacyFile, indexFile); } catch { /* compatibility-only */ }
+}
+
+function indexPaths({ migrate = false } = {}) {
+  const indexDir = join(cxDir(), knowledgeReferenceStore());
+  const legacyFile = join(cxDir(), 'product-intel', 'artifact-index.json');
+  const indexFile = join(indexDir, 'artifact-index.json');
+  if (migrate) migrateLegacyIndex(indexFile, legacyFile);
+  return {
+    indexDir,
+    indexFile,
+  };
+}
 
 const OVERLAP_THRESHOLD = 0.6;
 const CONTRADICTION_THRESHOLD = 0.7;
@@ -32,7 +47,8 @@ const STALE_INDEX_HOURS = 24;
  * Ensure index directory exists.
  */
 function ensureDir() {
-  if (!existsSync(INDEX_DIR)) mkdirSync(INDEX_DIR, { recursive: true });
+  const { indexDir } = indexPaths({ migrate: true });
+  if (!existsSync(indexDir)) mkdirSync(indexDir, { recursive: true });
 }
 
 let _artifactIndex = null;
@@ -55,9 +71,10 @@ export async function buildArtifactIndex({ rootDir, forceRebuild = false } = {})
   const cacheHash = cacheKey.length;
 
   // Check if cached index is fresh
-  if (!forceRebuild && existsSync(INDEX_FILE)) {
+  const { indexFile } = indexPaths();
+  if (!forceRebuild && existsSync(indexFile)) {
     try {
-      const cached = JSON.parse(readFileSync(INDEX_FILE, 'utf8'));
+      const cached = JSON.parse(readFileSync(indexFile, 'utf8'));
       if (cached.cacheHash === cacheHash && cached.index?.length === artifacts.length) {
         const age = Date.now() - new Date(cached.builtAt).getTime();
         if (age < STALE_INDEX_HOURS * 60 * 60 * 1000) {
@@ -96,7 +113,7 @@ export async function buildArtifactIndex({ rootDir, forceRebuild = false } = {})
     embedding: a.embedding ? Array.from(a.embedding) : null,
   }));
 
-  writeFileSync(INDEX_FILE, JSON.stringify({
+  writeFileSync(indexFile, JSON.stringify({
     cacheHash,
     builtAt: new Date().toISOString(),
     artifactCount: artifacts.length,

package/lib/embed/customer-profiles.mjs

@@ -1,31 +1,47 @@
 /**
  * lib/embed/customer-profiles.mjs — Global customer profile store.
  *
- * Maintains durable customer/account memory in ~/.cx/product-intel/customer-profiles/.
+ * Maintains durable customer/account memory in ~/.cx/knowledge/internal/customer-profiles/.
  * Profiles are additive — history is preserved unless explicitly deleted.
  * Links signals to customers and detects account-level patterns during intake triage.
  *
  * Storage:
- *   ~/.cx/product-intel/customer-profiles/<customer-id>.md
- *   ~/.cx/product-intel/customer-profiles/index.json — quick lookup by name/email
+ *   ~/.cx/knowledge/internal/customer-profiles/<customer-id>.md
+ *   ~/.cx/knowledge/internal/customer-profiles/index.json — quick lookup by name/email
  *
  * Each profile follows templates/docs/customer-profile.md schema.
  */
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync, appendFileSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync, appendFileSync, renameSync } from 'node:fs';
 import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
-import { homedir } from 'node:os';
+import { cxDir } from '../paths.mjs';
+import { knowledgeInternalStore } from '../knowledge/layout.mjs';
 
-const PROFILES_DIR = join(homedir(), '.cx', 'product-intel', 'customer-profiles');
-const INDEX_FILE = join(PROFILES_DIR, 'index.json');
+function migrateLegacyDir(modernDir, legacyDir) {
+  if (existsSync(modernDir) || !existsSync(legacyDir)) return;
+  mkdirSync(join(modernDir, '..'), { recursive: true });
+  try { renameSync(legacyDir, modernDir); } catch { /* compatibility-only */ }
+}
+
+function profilePaths({ migrate = false } = {}) {
+  const modernDir = join(cxDir(), knowledgeInternalStore('customer-profiles'));
+  const legacyDir = join(cxDir(), 'product-intel', 'customer-profiles');
+  if (migrate) migrateLegacyDir(modernDir, legacyDir);
+  const profilesDir = existsSync(modernDir) || !existsSync(legacyDir) ? modernDir : legacyDir;
+  return {
+    profilesDir,
+    indexFile: join(profilesDir, 'index.json'),
+  };
+}
 
 /**
  * Ensure profile directory exists.
  */
 function ensureDir() {
-  if (!existsSync(PROFILES_DIR)) {
-    mkdirSync(PROFILES_DIR, { recursive: true });
+  const { profilesDir } = profilePaths({ migrate: true });
+  if (!existsSync(profilesDir)) {
+    mkdirSync(profilesDir, { recursive: true });
   }
 }
 
@@ -34,9 +50,10 @@ function ensureDir() {
  * @returns {{ [key: string]: { id: string, name: string, status: string, updatedAt: string } }}
  */
 function readIndex() {
-  if (!existsSync(INDEX_FILE)) return {};
+  const { indexFile } = profilePaths();
+  if (!existsSync(indexFile)) return {};
   try {
-    return JSON.parse(readFileSync(INDEX_FILE, 'utf8'));
+    return JSON.parse(readFileSync(indexFile, 'utf8'));
   } catch (err) {
     process.stderr.write('[customer-profiles.mjs] readIndex: ' + (err?.message ?? String(err)) + '\n');
     return {};
@@ -48,8 +65,9 @@ function readIndex() {
  * @param {object} index
  */
 function writeIndex(index) {
+  const { indexFile } = profilePaths();
   ensureDir();
-  writeFileSync(INDEX_FILE, JSON.stringify(index, null, 2) + '\n');
+  writeFileSync(indexFile, JSON.stringify(index, null, 2) + '\n');
 }
 
 /**
@@ -95,7 +113,7 @@ export function createCustomerProfile({ name, owner, workspace, status = 'active
   const id = generateCustomerId();
   const slug = slugify(name);
   const filename = `${slug}-${id}.md`;
-  const filePath = join(PROFILES_DIR, filename);
+  const filePath = join(profilePaths().profilesDir, filename);
 
   const date = new Date().toISOString().slice(0, 10);
   const profile = {
@@ -219,12 +237,13 @@ TODO
  */
 export function getCustomerProfile(customerId) {
   ensureDir();
+  const { profilesDir } = profilePaths();
 
   // Try direct lookup by ID in filename
-  const files = readdirSync(PROFILES_DIR).filter(f => f.endsWith('.md'));
+  const files = readdirSync(profilesDir).filter(f => f.endsWith('.md'));
   for (const file of files) {
     if (file.includes(customerId)) {
-      const filePath = join(PROFILES_DIR, file);
+      const filePath = join(profilesDir, file);
       return parseProfileFile(filePath);
     }
   }
@@ -239,6 +258,7 @@ export function getCustomerProfile(customerId) {
  */
 export function searchCustomerProfiles(query) {
   ensureDir();
+  const { profilesDir } = profilePaths();
 
   const index = readIndex();
   const querySlug = slugify(query);
@@ -268,7 +288,7 @@ export function searchCustomerProfiles(query) {
             id: entry.id,
             name: entry.name,
             status: entry.status,
-            path: join(PROFILES_DIR, `${slugify(entry.name)}-${entry.id}.md`),
+            path: join(profilesDir, `${slugify(entry.name)}-${entry.id}.md`),
           });
         }
       }
@@ -328,7 +348,7 @@ export function updateCustomerProfile(customerId, updates) {
     throw new Error(`Customer profile not found: ${customerId}`);
   }
 
-  const filePath = join(PROFILES_DIR, `${slugify(profile.name)}-${customerId}.md`);
+  const filePath = join(profilePaths().profilesDir, `${slugify(profile.name)}-${customerId}.md`);
   let content = readFileSync(filePath, 'utf8');
   const date = new Date().toISOString().slice(0, 10);
 

package/lib/embed/daemon.mjs

@@ -467,15 +467,16 @@ export class EmbedDaemon {
           process.stderr.write(`[embed] Distilled ${itemsWritten} snapshot item(s) into observation store\n`);
         }
 
-        // Regenerate roadmap each tick so .cx/roadmap.md stays current and the
-        // missing-focal-resource gap clears on the next snapshot.
-        try {
-          const roadmap = generateRoadmap({ targetPath: this.#rootDir, snapshot, roles: this.#config?.roles });
-          if (!roadmap.skipped) {
-            process.stderr.write(`[embed] Roadmap refreshed: ${roadmap.itemCount} open item(s) → ${roadmap.path}\n`);
+        // Regenerate roadmap each tick unless disabled by the host config.
+        if (process.env.CONSTRUCT_EMBED_ROADMAP_ENABLED !== '0') {
+          try {
+            const roadmap = generateRoadmap({ targetPath: this.#rootDir, snapshot, roles: this.#config?.roles });
+            if (!roadmap.skipped) {
+              process.stderr.write(`[embed] Roadmap refreshed: ${roadmap.itemCount} open item(s) → ${roadmap.path}\n`);
+            }
+          } catch (err) {
+            process.stderr.write(`[embed] Roadmap refresh failed: ${err.message}\n`);
           }
-        } catch (err) {
-          process.stderr.write(`[embed] Roadmap refresh failed: ${err.message}\n`);
         }
       },
       { runImmediately: true },
@@ -744,6 +745,7 @@ this.#scheduler.register(
       'roadmap',
       60 * 60_000,
       async () => {
+        if (process.env.CONSTRUCT_EMBED_ROADMAP_ENABLED === '0') return;
         if (!this.#lastSnapshot) return; // wait until at least one snapshot exists
         try {
           const result = generateRoadmap({ targetPath: this.#rootDir, snapshot: this.#lastSnapshot, roles: this.#config?.roles });

package/lib/embed/recommendation-store.mjs

@@ -7,10 +7,14 @@
  * dismissal, automatic suppression after 7 days, and re-surfacing when
  * new signals arrive.
  *
- * Storage:
+ * Storage (solo mode):
  *   ~/.cx/intake/recommendations.jsonl — append-only log
  *   ~/.cx/intake/recommendations-index.json — fast lookup by id
  *
+ * Storage (team/enterprise mode — DATABASE_URL configured):
+ *   construct_recommendations table in Postgres (see db/schema/004_recommendations.sql)
+ *   JSONL store is also written as a local backup.
+ *
  * Prioritization formula:
  *   score = (signalCount * 2) + (customerImpact * 3) + (recencyBonus) + (strategicBonus)
  *   P0: score >= 10, P1: >= 7, P2: >= 4, P3: < 4
@@ -19,29 +23,38 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync, appendFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
-import { homedir } from 'node:os';
-
-const STORE_DIR = join(homedir(), '.cx', 'intake');
-const LOG_FILE = join(STORE_DIR, 'recommendations.jsonl');
-const INDEX_FILE = join(STORE_DIR, 'recommendations-index.json');
+import { cxDir } from '../paths.mjs';
+import { hasSqlStore } from '../storage/sql-store.mjs';
+import { createSqlClient } from '../storage/backend.mjs';
 
 const DEFAULT_SUPPRESS_DAYS = 7;
 const SUPERSEDE_WITHIN_HOURS = 72;
 
+function recommendationPaths() {
+  const storeDir = join(cxDir(), 'intake');
+  return {
+    storeDir,
+    logFile: join(storeDir, 'recommendations.jsonl'),
+    indexFile: join(storeDir, 'recommendations-index.json'),
+  };
+}
+
 /**
  * Ensure store directory exists.
  */
 function ensureDir() {
-  if (!existsSync(STORE_DIR)) mkdirSync(STORE_DIR, { recursive: true });
+  const { storeDir } = recommendationPaths();
+  if (!existsSync(storeDir)) mkdirSync(storeDir, { recursive: true });
 }
 
 /**
  * Read the index (fast lookup).
  */
 function readIndex() {
-  if (!existsSync(INDEX_FILE)) return {};
+  const { indexFile } = recommendationPaths();
+  if (!existsSync(indexFile)) return {};
   try {
-    return JSON.parse(readFileSync(INDEX_FILE, 'utf8'));
+    return JSON.parse(readFileSync(indexFile, 'utf8'));
   } catch {
     return {};
   }
@@ -51,8 +64,9 @@ function readIndex() {
  * Write the index.
  */
 function writeIndex(index) {
+  const { indexFile } = recommendationPaths();
   ensureDir();
-  writeFileSync(INDEX_FILE, JSON.stringify(index, null, 2) + '\n');
+  writeFileSync(indexFile, JSON.stringify(index, null, 2) + '\n');
 }
 
 /**
@@ -86,9 +100,11 @@ function dedupKey(type, title) {
  * @param {number} [opts.strategicBonus=0] - 0-3: strategic alignment
  * @param {string[]} [opts.sourceSignalIds] - IDs of intake signals that triggered this
  * @param {string} [opts.lane] - Docs lane this belongs to
+ * @param {string} [opts.project] - Project name (defaults to CX_PROJECT or 'default')
+ * @param {object} [opts.env] - Environment (defaults to process.env)
  * @returns {{ id: string, dedupKey: string, priority: string, score: number }}
  */
-export function createRecommendation({ type, title, reason, signalCount = 1, customerImpact = 0, recencyBonus = 0, strategicBonus = 0, sourceSignalIds = [], lane }) {
+export function createRecommendation({ type, title, reason, signalCount = 1, customerImpact = 0, recencyBonus = 0, strategicBonus = 0, sourceSignalIds = [], lane, project, env }) {
   if (!type || !title) throw new Error('type and title are required');
 
   ensureDir();
@@ -114,7 +130,10 @@ export function createRecommendation({ type, title, reason, signalCount = 1, cus
       updated.priority = priorityTier(score);
       index[key] = updated;
       writeIndex(index);
-      return { id: existing.id, dedupKey: key, priority: updated.priority, score, existing: true, updatedAt: updated.lastSeen };
+
+      const result = { id: existing.id, dedupKey: key, priority: updated.priority, score, existing: true, updatedAt: updated.lastSeen };
+      createRecommendationPgBestEffort(updated, project, env);
+      return result;
     }
     // Existing was dismissed — create new instance with new signals
     // (superseded recommendations can be revived with fresh signals)
@@ -145,12 +164,13 @@ export function createRecommendation({ type, title, reason, signalCount = 1, cus
   };
 
   // Append to log
-  appendFileSync(LOG_FILE, JSON.stringify(rec) + '\n', 'utf8');
+  appendFileSync(recommendationPaths().logFile, JSON.stringify(rec) + '\n', 'utf8');
 
   // Update index
   index[key] = rec;
   writeIndex(index);
 
+  createRecommendationPgBestEffort(rec, project, env);
   return { id, dedupKey: key, priority: rec.priority, score, existing: false };
 }
 
@@ -216,13 +236,28 @@ export function supersedeRecommendation(dedupKey, supersedingId) {
 /**
  * List active (non-dismissed, non-superseded) recommendations.
  *
+ * In team/enterprise mode (DATABASE_URL configured), reads from Postgres when
+ * the project has rows. Falls back to JSONL index.
+ *
  * @param {object} [opts]
  * @param {string} [opts.type] - Filter by type
  * @param {string} [opts.priority] - Filter by priority (P0, P1, etc.)
  * @param {number} [opts.limit=20]
+ * @param {string} [opts.project] - Project name (defaults to CX_PROJECT or 'default')
+ * @param {object} [opts.env] - Environment (defaults to process.env)
  * @returns {Array<object>}
  */
-export function listActiveRecommendations({ type, priority, limit = 20 } = {}) {
+export function listActiveRecommendations({ type, priority, limit = 20, project, env } = {}) {
+  if (hasSqlStore(env)) {
+    return listActiveRecommendationsPgWithFallback({ type, priority, limit, project, env });
+  }
+  return listActiveRecommendationsFile({ type, priority, limit });
+}
+
+/**
+ * File-based active recommendations list.
+ */
+function listActiveRecommendationsFile({ type, priority, limit = 20 } = {}) {
   const index = readIndex();
   const now = new Date();
   let results = Object.values(index).filter(rec => {
@@ -246,6 +281,27 @@ export function listActiveRecommendations({ type, priority, limit = 20 } = {}) {
     .slice(0, limit);
 }
 
+/**
+ * Attempt Postgres read, fall back to file synchronously.
+ * Returns a Promise so callers using await get Postgres data; callers not
+ * using await get the file-based results via the sync fallback.
+ */
+function listActiveRecommendationsPgWithFallback({ type, priority, limit, project, env }) {
+  const resolvedProject = project || (env || process.env).CX_PROJECT || 'default';
+  const client = createSqlClient(env);
+
+  return listActiveRecommendationsPg(resolvedProject, { type, priority, limit }, client)
+    .then(rows => {
+      client.end({ timeout: 5 }).catch(() => {});
+      if (rows.length > 0) return rows;
+      return listActiveRecommendationsFile({ type, priority, limit });
+    })
+    .catch(() => {
+      client.end({ timeout: 5 }).catch(() => {});
+      return listActiveRecommendationsFile({ type, priority, limit });
+    });
+}
+
 /**
  * Auto-suppress recommendations that have been active for DEFAULT_SUPPRESS_DAYS
  * without new signals, or that were superseded more than SUPERSEDE_WITHIN_HOURS ago.
@@ -376,3 +432,146 @@ export function isRecommendationActive(type, title) {
   if (rec.dismissedAt || rec.supersededAt) return { active: false, existing: rec };
   return { active: true, existing: rec };
 }
+
+// ---------------------------------------------------------------------------
+// Postgres backend — team/enterprise mode only
+// ---------------------------------------------------------------------------
+
+/**
+ * Upsert a recommendation into construct_recommendations.
+ * On conflict (project, dedup_key) update all mutable fields.
+ *
+ * @param {object} rec - Recommendation object (camelCase)
+ * @param {string} project
+ * @param {object} client - postgres.js SQL client
+ */
+export async function createRecommendationPg(rec, project, client) {
+  await client`
+    insert into construct_recommendations (
+      id, project, dedup_key, type, title, reason, lane,
+      signal_count, total_signal_count,
+      customer_impact, recency_bonus, strategic_bonus,
+      score, priority, source_signal_ids,
+      first_seen, last_seen,
+      dismissed_at, dismiss_reason,
+      superseded_at, superseded_by_id,
+      suppressed_until, suppress_reason,
+      updated_at
+    ) values (
+      ${rec.id}, ${project}, ${rec.dedupKey || dedupKey(rec.type, rec.title)}, ${rec.type}, ${rec.title},
+      ${rec.reason ?? null}, ${rec.lane ?? null},
+      ${rec.signalCount ?? 1}, ${rec.totalSignalCount ?? 1},
+      ${rec.customerImpact ?? 0}, ${rec.recencyBonus ?? 0}, ${rec.strategicBonus ?? 0},
+      ${rec.score ?? 0}, ${rec.priority ?? 'P3'},
+      ${JSON.stringify(rec.sourceSignalIds ?? [])}::jsonb,
+      ${rec.firstSeen ?? new Date().toISOString()}, ${rec.lastSeen ?? new Date().toISOString()},
+      ${rec.dismissedAt ?? null}, ${rec.dismissReason ?? null},
+      ${rec.supersededAt ?? null}, ${rec.supersededById ?? null},
+      ${rec.suppressedUntil ?? null}, ${rec.suppressReason ?? null},
+      now()
+    )
+    on conflict (project, dedup_key) do update set
+      signal_count        = excluded.signal_count,
+      total_signal_count  = excluded.total_signal_count,
+      customer_impact     = excluded.customer_impact,
+      recency_bonus       = excluded.recency_bonus,
+      strategic_bonus     = excluded.strategic_bonus,
+      score               = excluded.score,
+      priority            = excluded.priority,
+      source_signal_ids   = excluded.source_signal_ids,
+      last_seen           = excluded.last_seen,
+      dismissed_at        = excluded.dismissed_at,
+      dismiss_reason      = excluded.dismiss_reason,
+      superseded_at       = excluded.superseded_at,
+      superseded_by_id    = excluded.superseded_by_id,
+      suppressed_until    = excluded.suppressed_until,
+      suppress_reason     = excluded.suppress_reason,
+      updated_at          = now()
+  `;
+}
+
+/**
+ * Query active recommendations from Postgres for a project.
+ *
+ * @param {string} project
+ * @param {object} [opts]
+ * @param {string} [opts.type]
+ * @param {string} [opts.priority]
+ * @param {number} [opts.limit=20]
+ * @param {object} client - postgres.js SQL client
+ * @returns {Promise<Array<object>>}
+ */
+export async function listActiveRecommendationsPg(project, { type, priority, limit = 20 } = {}, client) {
+  const rows = await client`
+    select *
+    from construct_recommendations
+    where project = ${project}
+      and dismissed_at is null
+      and superseded_at is null
+      and (suppressed_until is null or suppressed_until <= now())
+      ${type ? client`and type = ${type}` : client``}
+      ${priority ? client`and priority = ${priority}` : client``}
+    order by score desc
+    limit ${limit}
+  `;
+
+  return rows.map(row => ({
+    id: row.id,
+    type: row.type,
+    title: row.title,
+    reason: row.reason,
+    lane: row.lane,
+    signalCount: row.signal_count,
+    totalSignalCount: row.total_signal_count,
+    customerImpact: row.customer_impact,
+    recencyBonus: row.recency_bonus,
+    strategicBonus: row.strategic_bonus,
+    score: row.score,
+    priority: row.priority,
+    sourceSignalIds: row.source_signal_ids ?? [],
+    firstSeen: row.first_seen instanceof Date ? row.first_seen.toISOString() : row.first_seen,
+    lastSeen: row.last_seen instanceof Date ? row.last_seen.toISOString() : row.last_seen,
+    dismissedAt: row.dismissed_at,
+    supersededAt: row.superseded_at,
+    suppressedUntil: row.suppressed_until,
+  }));
+}
+
+/**
+ * Dismiss a recommendation in Postgres.
+ *
+ * @param {string} dedupKeyValue
+ * @param {string} project
+ * @param {object} [opts]
+ * @param {string} [opts.reason]
+ * @param {number} [opts.suppressDays]
+ * @param {object} client - postgres.js SQL client
+ */
+export async function dismissRecommendationPg(dedupKeyValue, project, { reason = 'manually dismissed', suppressDays } = {}, client) {
+  const suppressedUntil = suppressDays
+    ? new Date(Date.now() + suppressDays * 24 * 60 * 60 * 1000).toISOString()
+    : null;
+
+  await client`
+    update construct_recommendations
+    set
+      dismissed_at    = now(),
+      dismiss_reason  = ${reason},
+      suppressed_until = ${suppressedUntil},
+      updated_at      = now()
+    where project = ${project}
+      and dedup_key = ${dedupKeyValue}
+  `;
+}
+
+/**
+ * Fire-and-forget Postgres upsert — never throws, never blocks the caller.
+ */
+function createRecommendationPgBestEffort(rec, project, env) {
+  if (!hasSqlStore(env)) return;
+  const resolvedProject = project || (env || process.env).CX_PROJECT || 'default';
+  const client = createSqlClient(env);
+  createRecommendationPg(rec, resolvedProject, client)
+    .catch(() => {})
+    .finally(() => client.end({ timeout: 5 }).catch(() => {}));
+}