@geraldmaron/construct 1.0.3 → 1.0.4

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(() => {}));
+}

package/lib/embed/workspaces.mjs

@@ -2,41 +2,61 @@
  * lib/embed/workspaces.mjs — Multi-PM workspace management.
  *
  * Workspaces isolate PM workstreams while enabling cross-workspace visibility.
- * Each workspace has an owner (PM), assigned customers, and product areas.
+ * Each workspace has an owner (PM), assigned customers, product areas, and a type.
+ *
+ * Workspace types: 'product' | 'platform' | 'enterprise' | 'growth' | 'ai-product'
+ * Default type: 'product'
  *
  * Storage:
- *   ~/.cx/product-intel/workspaces/<workspace-id>.json
- *   ~/.cx/product-intel/workspaces/index.json — quick lookup
+ *   ~/.cx/knowledge/internal/workspaces/<workspace-id>.json
+ *   ~/.cx/knowledge/internal/workspaces/index.json — quick lookup
  *
  * Intake packets are routed to workspaces based on customer assignment
  * or product area matching. Cross-workspace signals trigger notifications.
  */
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, 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';
+
+function migrateLegacyDir(modernDir, legacyDir) {
+  if (existsSync(modernDir) || !existsSync(legacyDir)) return;
+  mkdirSync(join(modernDir, '..'), { recursive: true });
+  try { renameSync(legacyDir, modernDir); } catch { /* compatibility-only */ }
+}
 
-const WORKSPACES_DIR = join(homedir(), '.cx', 'product-intel', 'workspaces');
-const INDEX_FILE = join(WORKSPACES_DIR, 'index.json');
+function workspacePaths({ migrate = false } = {}) {
+  const modernDir = join(cxDir(), knowledgeInternalStore('workspaces'));
+  const legacyDir = join(cxDir(), 'product-intel', 'workspaces');
+  if (migrate) migrateLegacyDir(modernDir, legacyDir);
+  const workspacesDir = existsSync(modernDir) || !existsSync(legacyDir) ? modernDir : legacyDir;
+  return {
+    workspacesDir,
+    indexFile: join(workspacesDir, 'index.json'),
+  };
+}
 
 /**
  * Ensure workspaces directory exists.
  */
 function ensureDir() {
-  if (!existsSync(WORKSPACES_DIR)) {
-    mkdirSync(WORKSPACES_DIR, { recursive: true });
+  const { workspacesDir } = workspacePaths({ migrate: true });
+  if (!existsSync(workspacesDir)) {
+    mkdirSync(workspacesDir, { recursive: true });
   }
 }
 
 /**
  * Read the index file.
- * @returns {{ [key: string]: { id: string, name: string, owner: string, status: string } }}
+ * @returns {{ [key: string]: { id: string, name: string, owner: string, status: string, type: string } }}
  */
 function readIndex() {
-  if (!existsSync(INDEX_FILE)) return {};
+  const { indexFile } = workspacePaths();
+  if (!existsSync(indexFile)) return {};
   try {
-    return JSON.parse(readFileSync(INDEX_FILE, 'utf8'));
+    return JSON.parse(readFileSync(indexFile, 'utf8'));
   } catch (err) {
     process.stderr.write('[workspaces.mjs] readIndex: ' + (err?.message ?? String(err)) + '\n');
     return {};
@@ -48,10 +68,13 @@ function readIndex() {
  * @param {object} index
  */
 function writeIndex(index) {
+  const { indexFile } = workspacePaths();
   ensureDir();
-  writeFileSync(INDEX_FILE, JSON.stringify(index, null, 2) + '\n');
+  writeFileSync(indexFile, JSON.stringify(index, null, 2) + '\n');
 }
 
+const VALID_WORKSPACE_TYPES = ['product', 'platform', 'enterprise', 'growth', 'ai-product'];
+
 /**
  * Create a new workspace.
  *
@@ -61,15 +84,19 @@ function writeIndex(index) {
  * @param {string} [opts.description] - Workspace description
  * @param {string[]} [opts.productAreas] - Product areas this workspace covers
  * @param {string[]} [opts.customerIds] - Customer IDs assigned to this workspace
+ * @param {string} [opts.type] - Workspace type: 'product' | 'platform' | 'enterprise' | 'growth' | 'ai-product' (default: 'product')
  * @returns {{ id: string, workspace: Workspace }}
  */
-export function createWorkspace({ name, owner, description, productAreas = [], customerIds = [] }) {
+export function createWorkspace({ name, owner, description, productAreas = [], customerIds = [], type = 'product' }) {
   if (!name || typeof name !== 'string' || !name.trim()) {
     throw new Error('name is required');
   }
   if (!owner || typeof owner !== 'string' || !owner.trim()) {
     throw new Error('owner is required');
   }
+  if (!VALID_WORKSPACE_TYPES.includes(type)) {
+    throw new Error(`type must be one of: ${VALID_WORKSPACE_TYPES.join(', ')}`);
+  }
 
   ensureDir();
 
@@ -79,6 +106,7 @@ export function createWorkspace({ name, owner, description, productAreas = [], c
     name: name.trim(),
     owner,
     description: description || '',
+    type,
     productAreas,
     customerIds,
     status: 'active',
@@ -86,7 +114,7 @@ export function createWorkspace({ name, owner, description, productAreas = [], c
     updatedAt: new Date().toISOString(),
   };
 
-  const filePath = join(WORKSPACES_DIR, `${id}.json`);
+  const filePath = join(workspacePaths().workspacesDir, `${id}.json`);
   writeFileSync(filePath, JSON.stringify(workspace, null, 2) + '\n');
 
   // Update index
@@ -96,6 +124,7 @@ export function createWorkspace({ name, owner, description, productAreas = [], c
     name: workspace.name,
     owner: workspace.owner,
     status: workspace.status,
+    type: workspace.type,
   };
   writeIndex(index);
 
@@ -110,7 +139,7 @@ export function createWorkspace({ name, owner, description, productAreas = [], c
 export function getWorkspace(workspaceId) {
   ensureDir();
 
-  const filePath = join(WORKSPACES_DIR, `${workspaceId}.json`);
+  const filePath = join(workspacePaths().workspacesDir, `${workspaceId}.json`);
   if (!existsSync(filePath)) return null;
 
   try {
@@ -156,6 +185,7 @@ export function listWorkspaces(opts = {}) {
  * @param {string[]} [updates.productAreas]
  * @param {string[]} [updates.customerIds]
  * @param {string} [updates.status]
+ * @param {string} [updates.type] - 'product' | 'platform' | 'enterprise' | 'growth' | 'ai-product'
  * @returns {{ success: boolean, updatedAt: string }}
  */
 export function updateWorkspace(workspaceId, updates) {
@@ -164,13 +194,17 @@ export function updateWorkspace(workspaceId, updates) {
     throw new Error(`Workspace not found: ${workspaceId}`);
   }
 
+  if (updates.type !== undefined && !VALID_WORKSPACE_TYPES.includes(updates.type)) {
+    throw new Error(`type must be one of: ${VALID_WORKSPACE_TYPES.join(', ')}`);
+  }
+
   const updated = {
     ...workspace,
     ...updates,
     updatedAt: new Date().toISOString(),
   };
 
-  const filePath = join(WORKSPACES_DIR, `${workspaceId}.json`);
+  const filePath = join(workspacePaths().workspacesDir, `${workspaceId}.json`);
   writeFileSync(filePath, JSON.stringify(updated, null, 2) + '\n');
 
   // Update index
@@ -181,6 +215,7 @@ export function updateWorkspace(workspaceId, updates) {
       name: updated.name,
       owner: updated.owner,
       status: updated.status,
+      type: updated.type ?? workspace.type ?? 'product',
     };
     writeIndex(index);
   }
@@ -194,7 +229,7 @@ export function updateWorkspace(workspaceId, updates) {
  * @returns {{ success: boolean }}
  */
 export function deleteWorkspace(workspaceId) {
-  const filePath = join(WORKSPACES_DIR, `${workspaceId}.json`);
+  const filePath = join(workspacePaths().workspacesDir, `${workspaceId}.json`);
   if (!existsSync(filePath)) {
     throw new Error(`Workspace not found: ${workspaceId}`);
   }

package/lib/gates-audit.mjs

@@ -42,7 +42,7 @@ const GATE_DEFINITIONS = [
   { ciJob: 'secret scanning',                prePushLabel: null,  preCommitCheck: 'ECC secret scan',               critical: true, note: 'pre-commit ECC scan covers a subset of gitleaks rules' },
   { ciJob: 'postgres + pgvector integration', prePushLabel: null, preCommitCheck: null,                            critical: false, note: 'CI-only: requires Docker Postgres + pgvector container; not practical locally', localMirror: 'ci-only' },
   { ciJob: 'docs drift check',               prePushLabel: 'docs', critical: true },
-  { ciJob: 'comment policy',                 prePushLabel: null,  preCommitCheck: 'Construct comment-lint (staged)', critical: true, note: 'pre-commit Construct policy section calls `lint:comments --staged`' },
+  { ciJob: 'comment policy',                 prePushLabel: null,  preCommitCheck: 'Construct comment-lint', critical: true, note: 'pre-commit Construct policy section calls `lint:comments` across the full worktree' },
   { ciJob: 'template policy',                prePushLabel: null,  preCommitGhPrIntercept: true,                    critical: true, note: 'pre-push-gate intercepts `gh pr create` / `gh pr edit` and lints the body' },
 ];
 
@@ -68,8 +68,8 @@ function parsePreCommitChecks(rootDir) {
   const src = readFileSync(path, 'utf8');
   const checks = [];
   if (src.includes('scan_added_lines')) checks.push('ECC secret scan');
-  if (src.includes('construct lint:comments --staged')) checks.push('Construct comment-lint (staged)');
-  if (src.includes('construct docs:verify --staged')) checks.push('Construct docs:verify (staged)');
+  if (src.includes('construct lint:comments')) checks.push('Construct comment-lint');
+  if (src.includes('construct docs:verify')) checks.push('Construct docs:verify');
   if (src.includes('BEADS INTEGRATION')) checks.push('BEADS dispatcher');
   return checks;
 }

package/lib/health-check.mjs

@@ -67,7 +67,7 @@ export async function checkPrerequisites(options = {}) {
     required: true,
     installed: hasDocker,
     version: dockerVersion,
-    why: 'Required for telemetry backend (trace observability) and managed Postgres',
+    why: 'Required for managed Postgres; trace capture works locally without Docker',
     install: isWindows 
       ? 'https://docs.docker.com/desktop/install/windows-install/'
       : 'https://docs.docker.com/get-docker/',

package/lib/hooks/pre-compact.mjs

@@ -11,10 +11,13 @@ import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
 import { writeContextState } from '../context-state.mjs';
+import { flushReadTrackerDeltas } from '../read-tracker-store.mjs';
 
 let input = {};
 try { input = JSON.parse(readFileSync(0, 'utf8')); } catch { process.exit(0); }
 
+try { flushReadTrackerDeltas({ env: process.env }); } catch { /* best effort */ }
+
 const cwd = input?.cwd || process.cwd();
 const transcriptPath = input?.transcript_path || '';