agenr 0.9.60 → 0.9.61

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.9.61] - 2026-03-03
+
+### Added
+
+- **Synthetic cold-start signals** (#417 Phase 3): `agenr ingest --bulk --synthetic` now runs a post-ingest cross-session mention analysis pass. Entries that appear across multiple session transcripts receive synthetic recall events so they start with meaningful recall profiles instead of flat zero-history signals.
+- `--synthetic` and `--synthetic-dry-run` flags for `agenr ingest`.
+- Quality score seeding from synthetic recall signals with four tiers (`0.6`, `0.65`, `0.7`, `0.8`) based on distinct session count and temporal spread. Seeding is guarded so only entries still at `quality_score = 0.5` are updated.
+
+### Improvements
+
+- Synthetic event generation writes flat `signal_value = 0.4` per event (frequency is carried by event count), caps ANN fan-out at top-5 neighbors per entry, and uses chunked transaction batches with `INSERT OR IGNORE` idempotency on the existing synthetic dedup index.
+
 ## 0.9.60 (2026-03-03)
 
 ### Features

package/dist/cli-main.js

@@ -81,6 +81,7 @@ import {
   clearBulkIngestMeta,
   closeDb,
   composeEmbeddingText,
+  cosineSimilarity,
   createLlmClient,
   createLogger,
   describeAuth,
@@ -93,6 +94,7 @@ import {
   initSchema,
   isCompleteConfig,
   isRecord,
+  mapBufferToVector,
   maskSecret,
   mergeConfigPatch,
   normalizeLabel,
@@ -122,6 +124,7 @@ import {
   getTopCoRecallEdges,
   parseDaysBetween,
   toNumber,
+  toRowsAffected,
   toStringValue
 } from "./chunk-D7W3PO7U.js";
 
@@ -11355,6 +11358,415 @@ import fs24 from "fs/promises";
 import path22 from "path";
 import * as clack9 from "@clack/prompts";
 
+// src/db/recall/synthetic.ts
+import { randomUUID } from "crypto";
+var DEFAULT_SIMILARITY_THRESHOLD = 0.75;
+var DEFAULT_MIN_SESSION_COUNT = 2;
+var VECTOR_FAN_OUT = 5;
+var DEFAULT_MAX_EVENTS_PER_ENTRY = VECTOR_FAN_OUT;
+var DEFAULT_SIGNAL_VALUE = 0.4;
+var INSERT_BATCH_SIZE = 500;
+function normalizeSourceFiles(sourceFiles) {
+  if (!sourceFiles || sourceFiles.length === 0) {
+    return [];
+  }
+  return Array.from(
+    new Set(
+      sourceFiles.map((value) => value.trim()).filter((value) => value.length > 0)
+    )
+  );
+}
+function normalizeThreshold(value) {
+  if (!Number.isFinite(value)) {
+    return DEFAULT_SIMILARITY_THRESHOLD;
+  }
+  const normalized = Number(value);
+  if (normalized <= 0) {
+    return 0;
+  }
+  if (normalized >= 1) {
+    return 1;
+  }
+  return normalized;
+}
+function normalizePositiveInt2(value, fallback) {
+  if (!Number.isFinite(value)) {
+    return fallback;
+  }
+  const parsed = Math.floor(Number(value));
+  if (parsed < 1) {
+    return fallback;
+  }
+  return parsed;
+}
+function normalizeNullableText(value) {
+  const text4 = toStringValue(value).trim();
+  return text4.length > 0 ? text4 : null;
+}
+function normalizeTimestamp(value, fallbackIso) {
+  const parsed = new Date(value);
+  if (Number.isFinite(parsed.getTime())) {
+    return parsed.toISOString();
+  }
+  return fallbackIso;
+}
+async function loadEntryCandidates(db, sourceFiles) {
+  const scopedPlaceholders = sourceFiles.map(() => "?").join(", ");
+  const scopedClause = sourceFiles.length > 0 ? `AND source_file IN (${scopedPlaceholders})` : "";
+  const result = await db.execute({
+    sql: `
+      SELECT
+        id,
+        source_file,
+        created_at,
+        subject,
+        norm_content_hash,
+        platform,
+        project,
+        embedding
+      FROM entries
+      WHERE retired = 0
+        AND superseded_by IS NULL
+        ${scopedClause}
+    `,
+    args: sourceFiles
+  });
+  return result.rows.map((row) => {
+    const sourceFile = toStringValue(row.source_file).trim();
+    return {
+      id: toStringValue(row.id),
+      sourceFile,
+      createdAt: toStringValue(row.created_at),
+      subject: normalizeNullableText(row.subject),
+      fingerprint: normalizeNullableText(row.norm_content_hash),
+      platform: normalizeNullableText(row.platform),
+      project: normalizeNullableText(row.project),
+      embedding: row.embedding ? mapBufferToVector(row.embedding) : null
+    };
+  }).filter((row) => row.id.length > 0);
+}
+async function loadEntryMetadata(db) {
+  const result = await db.execute({
+    sql: `
+      SELECT id, source_file, created_at, platform, project
+      FROM entries
+      WHERE retired = 0
+        AND superseded_by IS NULL
+    `
+  });
+  const metadata = /* @__PURE__ */ new Map();
+  for (const row of result.rows) {
+    const id = toStringValue(row.id);
+    if (id.length === 0) {
+      continue;
+    }
+    metadata.set(id, {
+      sourceFile: toStringValue(row.source_file).trim(),
+      createdAt: toStringValue(row.created_at),
+      platform: normalizeNullableText(row.platform),
+      project: normalizeNullableText(row.project)
+    });
+  }
+  return metadata;
+}
+function createDefaultVectorSearch(db, embeddingsByEntryId) {
+  return async (entryId, k, threshold) => {
+    const queryEmbedding = embeddingsByEntryId.get(entryId);
+    if (!queryEmbedding || queryEmbedding.length === 0) {
+      return [];
+    }
+    const result = await db.execute({
+      sql: `
+        SELECT e.id, e.embedding
+        FROM vector_top_k('idx_entries_embedding', vector32(?), ?) AS v
+        CROSS JOIN entries AS e ON e.rowid = v.id
+        WHERE e.embedding IS NOT NULL
+          AND e.retired = 0
+          AND e.superseded_by IS NULL
+      `,
+      args: [JSON.stringify(queryEmbedding), k + 1]
+    });
+    const neighbors = [];
+    for (const row of result.rows) {
+      const id = toStringValue(row.id);
+      if (id.length === 0 || id === entryId) {
+        continue;
+      }
+      const embedding = mapBufferToVector(row.embedding);
+      if (embedding.length === 0) {
+        continue;
+      }
+      const score = cosineSimilarity(queryEmbedding, embedding);
+      if (score >= threshold) {
+        neighbors.push({ id, score });
+      }
+    }
+    neighbors.sort((left, right) => right.score - left.score);
+    return neighbors.slice(0, k);
+  };
+}
+function toSyntheticQualityMentions(entry, neighbors, metadataById, similarityThreshold, fallbackIso) {
+  const mentionsBySession = /* @__PURE__ */ new Map();
+  for (const neighbor of neighbors) {
+    if (neighbor.score < similarityThreshold) {
+      continue;
+    }
+    const metadata = metadataById.get(neighbor.id);
+    if (!metadata) {
+      continue;
+    }
+    const sessionId = metadata.sourceFile.trim();
+    if (sessionId.length === 0 || sessionId === entry.sourceFile) {
+      continue;
+    }
+    const mention = {
+      sessionId,
+      recalledAt: normalizeTimestamp(metadata.createdAt, fallbackIso),
+      score: neighbor.score,
+      platform: metadata.platform,
+      project: metadata.project
+    };
+    const existing = mentionsBySession.get(sessionId);
+    if (!existing || mention.score > existing.score) {
+      mentionsBySession.set(sessionId, mention);
+    }
+  }
+  return [...mentionsBySession.values()];
+}
+async function insertSyntheticEvents(db, events) {
+  let inserted = 0;
+  for (let index = 0; index < events.length; index += INSERT_BATCH_SIZE) {
+    const chunk = events.slice(index, index + INSERT_BATCH_SIZE);
+    await db.execute("BEGIN IMMEDIATE");
+    try {
+      for (const event of chunk) {
+        const result = await db.execute({
+          sql: `
+            INSERT OR IGNORE INTO recall_events (
+              id,
+              entry_id,
+              content_fingerprint,
+              subject_key,
+              session_id,
+              platform,
+              project,
+              source,
+              signal_type,
+              signal_value,
+              recalled_at,
+              created_at
+            )
+            VALUES (?, ?, ?, ?, ?, ?, ?, 'synthetic', 'cross_session_mention', ?, ?, ?)
+          `,
+          args: [
+            randomUUID(),
+            event.entryId,
+            event.fingerprint,
+            event.subject,
+            event.sessionId,
+            event.platform,
+            event.project,
+            DEFAULT_SIGNAL_VALUE,
+            event.recalledAt,
+            event.recalledAt
+          ]
+        });
+        inserted += Math.max(0, toRowsAffected(result.rowsAffected));
+      }
+      await db.execute("COMMIT");
+    } catch (error) {
+      try {
+        await db.execute("ROLLBACK");
+      } catch {
+      }
+      throw error;
+    }
+  }
+  if (events.length > 0) {
+    await db.execute("ANALYZE recall_events");
+    await db.execute("PRAGMA optimize");
+  }
+  return inserted;
+}
+async function generateSyntheticEvents(options) {
+  const startedAt = Date.now();
+  const sourceFiles = normalizeSourceFiles(options.sourceFiles);
+  const similarityThreshold = normalizeThreshold(options.similarityThreshold);
+  const minSessionCount = normalizePositiveInt2(options.minSessionCount, DEFAULT_MIN_SESSION_COUNT);
+  const maxEventsPerEntry = normalizePositiveInt2(options.maxEventsPerEntry, DEFAULT_MAX_EVENTS_PER_ENTRY);
+  const dryRun = options.dryRun === true;
+  const entries = await loadEntryCandidates(options.db, sourceFiles);
+  const entriesAnalyzed = entries.length;
+  if (entriesAnalyzed === 0) {
+    return {
+      entriesAnalyzed,
+      entriesQualified: 0,
+      eventsEmitted: 0,
+      durationMs: Math.max(0, Date.now() - startedAt)
+    };
+  }
+  const metadataById = await loadEntryMetadata(options.db);
+  const embeddingsByEntryId = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.embedding && entry.embedding.length > 0) {
+      embeddingsByEntryId.set(entry.id, entry.embedding);
+    }
+  }
+  const vectorSearch = options.vectorSearch ?? createDefaultVectorSearch(options.db, embeddingsByEntryId);
+  const fallbackIso = (/* @__PURE__ */ new Date()).toISOString();
+  const eventsToInsert = [];
+  let entriesQualified = 0;
+  for (const entry of entries) {
+    if (!entry.embedding || entry.embedding.length === 0) {
+      continue;
+    }
+    if (!entry.fingerprint || entry.fingerprint.length === 0) {
+      continue;
+    }
+    if (entry.sourceFile.length === 0) {
+      continue;
+    }
+    const neighbors = await vectorSearch(entry.id, VECTOR_FAN_OUT, similarityThreshold);
+    const mentions = toSyntheticQualityMentions(entry, neighbors, metadataById, similarityThreshold, fallbackIso);
+    const sessionCount = mentions.length;
+    if (sessionCount < minSessionCount) {
+      continue;
+    }
+    entriesQualified += 1;
+    mentions.sort((left, right) => right.score - left.score || left.recalledAt.localeCompare(right.recalledAt)).slice(0, maxEventsPerEntry).forEach((mention) => {
+      eventsToInsert.push({
+        entryId: entry.id,
+        fingerprint: entry.fingerprint,
+        subject: entry.subject,
+        sessionId: mention.sessionId,
+        platform: mention.platform ?? entry.platform,
+        project: mention.project ?? entry.project,
+        recalledAt: mention.recalledAt
+      });
+    });
+  }
+  const eventsEmitted = dryRun ? eventsToInsert.length : await insertSyntheticEvents(options.db, eventsToInsert);
+  if (options.verbose === true) {
+    process.stderr.write(
+      `[synthetic] analyzed ${entriesAnalyzed} entries, qualified ${entriesQualified}, ${dryRun ? "would emit" : "emitted"} ${eventsEmitted} events
+`
+    );
+  }
+  return {
+    entriesAnalyzed,
+    entriesQualified,
+    eventsEmitted,
+    durationMs: Math.max(0, Date.now() - startedAt)
+  };
+}
+
+// src/quality/seed.ts
+function normalizeSourceFiles2(sourceFiles) {
+  if (!sourceFiles || sourceFiles.length === 0) {
+    return [];
+  }
+  return Array.from(
+    new Set(
+      sourceFiles.map((value) => value.trim()).filter((value) => value.length > 0)
+    )
+  );
+}
+function parseCount(value) {
+  const parsed = toNumber(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return 0;
+  }
+  return Math.floor(parsed);
+}
+function parseSpreadDays(value) {
+  const parsed = toNumber(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return 0;
+  }
+  return parsed;
+}
+function resolveSeedQuality(candidate) {
+  if (candidate.sessionCount >= 10 && candidate.temporalSpreadDays >= 30) {
+    return 0.8;
+  }
+  if (candidate.sessionCount >= 5 && candidate.temporalSpreadDays >= 14) {
+    return 0.7;
+  }
+  if (candidate.sessionCount >= 3 && candidate.temporalSpreadDays >= 7) {
+    return 0.65;
+  }
+  if (candidate.sessionCount >= 2) {
+    return 0.6;
+  }
+  return null;
+}
+async function loadSeedCandidates(db, sourceFiles) {
+  const placeholders = sourceFiles.map(() => "?").join(", ");
+  const sourceScopeClause = sourceFiles.length > 0 ? `AND e.source_file IN (${placeholders})` : "";
+  const result = await db.execute({
+    sql: `
+      SELECT
+        e.id AS entry_id,
+        COUNT(DISTINCT re.session_id) AS session_count,
+        COALESCE(julianday(MAX(re.recalled_at)) - julianday(MIN(re.recalled_at)), 0) AS temporal_spread_days
+      FROM entries AS e
+      INNER JOIN recall_events AS re ON re.entry_id = e.id
+      WHERE e.retired = 0
+        AND e.superseded_by IS NULL
+        AND re.source = 'synthetic'
+        AND re.session_id IS NOT NULL
+        ${sourceScopeClause}
+      GROUP BY e.id
+    `,
+    args: sourceFiles
+  });
+  const candidates = [];
+  for (const row of result.rows) {
+    const entryId = toStringValue(row.entry_id);
+    if (entryId.length === 0) {
+      continue;
+    }
+    candidates.push({
+      entryId,
+      sessionCount: parseCount(row.session_count),
+      temporalSpreadDays: parseSpreadDays(row.temporal_spread_days)
+    });
+  }
+  return candidates;
+}
+async function seedQualityScores(db, sourceFiles) {
+  const normalizedSourceFiles = normalizeSourceFiles2(sourceFiles);
+  const candidates = await loadSeedCandidates(db, normalizedSourceFiles);
+  let updated = 0;
+  await db.execute("BEGIN IMMEDIATE");
+  try {
+    for (const candidate of candidates) {
+      const qualityScore = resolveSeedQuality(candidate);
+      if (qualityScore === null) {
+        continue;
+      }
+      const result = await db.execute({
+        sql: `
+          UPDATE entries
+          SET quality_score = ?
+          WHERE id = ?
+            AND quality_score = 0.5
+        `,
+        args: [qualityScore, candidate.entryId]
+      });
+      updated += Math.max(0, toRowsAffected(result.rowsAffected));
+    }
+    await db.execute("COMMIT");
+  } catch (error) {
+    try {
+      await db.execute("ROLLBACK");
+    } catch {
+    }
+    throw error;
+  }
+  return { updated };
+}
+
 // src/ingest/write-queue.ts
 var CancelledError = class extends Error {
   constructor(message = "Write queue item was cancelled.") {
@@ -11997,7 +12409,7 @@ async function resolveInputFiles(inputPaths, globPattern, expandInputFilesFn) {
 
 // src/commands/ingest/helpers.ts
 import path19 from "path";
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 function retryBackoffMs(attempt) {
   if (attempt <= 1) return 1e4;
   if (attempt === 2) return 3e4;
@@ -12149,7 +12561,7 @@ async function insertIngestLogForFile(db, params) {
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `,
     args: [
-      randomUUID(),
+      randomUUID2(),
       params.filePath,
       params.contentHash,
       (/* @__PURE__ */ new Date()).toISOString(),
@@ -12818,7 +13230,9 @@ async function runIngestCommand(inputPaths, options, deps) {
     sleepFn: deps?.sleepFn ?? sleep,
     shouldShutdownFn: deps?.shouldShutdownFn ?? isShutdownRequested,
     createWriteQueueFn: deps?.createWriteQueueFn ?? ((queueOptions) => new WriteQueue(queueOptions)),
-    embedFn: deps?.embedFn ?? embed
+    embedFn: deps?.embedFn ?? embed,
+    generateSyntheticEventsFn: deps?.generateSyntheticEventsFn ?? generateSyntheticEvents,
+    seedQualityScoresFn: deps?.seedQualityScoresFn ?? seedQualityScores
   };
   const clackOutput = { output: process.stderr };
   clack9.intro(banner(), clackOutput);
@@ -12858,6 +13272,8 @@ async function runIngestCommand(inputPaths, options, deps) {
   const dryRun = options.dryRun === true;
   const bulkRequested = options.bulk === true;
   const bulkMode = bulkRequested && !dryRun;
+  const syntheticRequested = options.synthetic === true;
+  const syntheticDryRun = options.syntheticDryRun === true;
   const json = options.json === true;
   const force = options.force === true;
   const skipIngested = force ? false : options.skipIngested !== false;
@@ -12895,6 +13311,15 @@ async function runIngestCommand(inputPaths, options, deps) {
   if (bulkRequested && dryRun) {
     clack9.log.warn(formatWarn("[bulk] --bulk is ignored when --dry-run is enabled."), clackOutput);
   }
+  if (syntheticDryRun && !syntheticRequested) {
+    clack9.log.warn(
+      formatWarn("[synthetic] --synthetic-dry-run requires --synthetic; synthetic pass will be skipped."),
+      clackOutput
+    );
+  }
+  if (syntheticRequested && !bulkRequested) {
+    clack9.log.warn(formatWarn("[synthetic] --synthetic requires --bulk; synthetic pass will be skipped."), clackOutput);
+  }
   const files = await resolveInputFiles(inputPaths, globPattern, resolvedDeps.expandInputFilesFn);
   const targetsWithSizes = await Promise.all(
     files.map(async (filePath) => {
@@ -13064,6 +13489,9 @@ async function runIngestCommand(inputPaths, options, deps) {
   let firstPassFailedIndexSet = /* @__PURE__ */ new Set();
   let bulkTeardownComplete = false;
   let bulkVectorRebuildDurationSeconds = null;
+  let syntheticSummaryLine = null;
+  let qualitySeedLine = null;
+  let syntheticResult = null;
   let cleanupFailure = null;
   let pipelineError = null;
   const updateProgressFn = (completedCount, totalCount, verb) => {
@@ -13165,6 +13593,40 @@ async function runIngestCommand(inputPaths, options, deps) {
         cleanupFailure = asError(error);
       }
     }
+    const shouldRunSyntheticPass = bulkMode && syntheticRequested && !syntheticDryRun && state.totalEntriesStored > 0 && !stoppedForShutdown && !pipelineError && !cleanupFailure;
+    const shouldRunSyntheticDryRun = bulkMode && syntheticRequested && syntheticDryRun && state.totalEntriesStored > 0 && !stoppedForShutdown && !pipelineError && !cleanupFailure;
+    if (shouldRunSyntheticPass || shouldRunSyntheticDryRun) {
+      const syntheticSourceFiles = Array.from(
+        new Set(
+          results.filter(
+            (result) => Boolean(result) && !result.error && !result.skipped && result.entriesStored > 0
+          ).map((result) => result.file)
+        )
+      );
+      try {
+        let qualitySeeded = 0;
+        if (!syntheticDryRun) {
+          const seededBefore = await resolvedDeps.seedQualityScoresFn(db, syntheticSourceFiles);
+          qualitySeeded += seededBefore.updated;
+        }
+        syntheticResult = await resolvedDeps.generateSyntheticEventsFn({
+          db,
+          sourceFiles: syntheticSourceFiles,
+          dryRun: syntheticDryRun,
+          verbose
+        });
+        if (!syntheticDryRun) {
+          const seededAfter = await resolvedDeps.seedQualityScoresFn(db, syntheticSourceFiles);
+          qualitySeeded += seededAfter.updated;
+        }
+        const syntheticVerb = syntheticDryRun ? "would emit" : "emitted";
+        syntheticSummaryLine = `Synthetic recall events: analyzed ${syntheticResult.entriesAnalyzed} entries, ${syntheticVerb} ${syntheticResult.eventsEmitted} events for ${syntheticResult.entriesQualified} entries`;
+        qualitySeedLine = qualitySeeded > 0 ? `Quality seeding: updated ${qualitySeeded} entries.` : null;
+      } catch (error) {
+        clack9.log.error(formatError(`[synthetic] post-ingest synthesis failed: ${toErrorMessage(error)}`), clackOutput);
+        cleanupFailure = asError(error);
+      }
+    }
     if (!dryRun) {
       try {
         await walCheckpoint(db);
@@ -13243,7 +13705,16 @@ async function runIngestCommand(inputPaths, options, deps) {
   const bulkRebuildLine = bulkMode && bulkVectorRebuildDurationSeconds !== null ? `Bulk mode: FTS rebuild + vector index rebuilt in ${bulkVectorRebuildDurationSeconds.toFixed(1)}s.` : null;
   const bulkDedupLine = bulkMode ? `Bulk dedup: ${bulkDedupSkippedHashMinhash} entries skipped (hash/MinHash).` : null;
   clack9.note(
-    [doneLine, chunkFailureLine, bulkRebuildLine, bulkDedupLine, ...retryLines, ...failedFileLines].filter((line) => Boolean(line)).join("\n"),
+    [
+      doneLine,
+      chunkFailureLine,
+      bulkRebuildLine,
+      bulkDedupLine,
+      syntheticSummaryLine,
+      qualitySeedLine,
+      ...retryLines,
+      ...failedFileLines
+    ].filter((line) => Boolean(line)).join("\n"),
     "Ingest Complete",
     clackOutput
   );
@@ -13282,6 +13753,14 @@ function registerIngestCommand(program) {
     "--bulk",
     "Optimize large imports by disabling FTS/vector indexes during writes and rebuilding afterward",
     false
+  ).option(
+    "--synthetic",
+    "Run synthetic recall event generation after bulk ingest (requires --bulk)",
+    false
+  ).option(
+    "--synthetic-dry-run",
+    "Show what synthetic recall events would be generated without writing (requires --synthetic)",
+    false
   ).option("--no-retry", "Disable auto-retry for failed files").option("--no-pre-fetch", "Disable elaborative encoding pre-fetch").option(
     "--whole-file",
     "Force whole-file extraction mode. Sends each file as a single LLM call. Auto-detected for large-context models; use this flag to force it for any model. Ignored in watch mode.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agenr",
-  "version": "0.9.60",
+  "version": "0.9.61",
   "openclaw": {
     "extensions": [
       "dist/openclaw-plugin/index.js"
@@ -11,6 +11,13 @@
   "bin": {
     "agenr": "dist/cli.js"
   },
+  "scripts": {
+    "build": "tsup src/cli.ts src/cli-main.ts src/openclaw-plugin/index.ts --format esm --dts",
+    "dev": "tsup src/cli.ts src/cli-main.ts --format esm --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
   "dependencies": {
     "@clack/prompts": "^1.0.1",
     "@libsql/client": "^0.17.0",
@@ -54,11 +61,9 @@
     "README.md"
   ],
   "author": "agenr-ai",
-  "scripts": {
-    "build": "tsup src/cli.ts src/cli-main.ts src/openclaw-plugin/index.ts --format esm --dts",
-    "dev": "tsup src/cli.ts src/cli-main.ts --format esm --watch",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "typecheck": "tsc --noEmit"
+  "pnpm": {
+    "overrides": {
+      "fast-xml-parser": "^5.3.6"
+    }
   }
-}
+}