sinapse-ai 1.20.0 → 1.21.0

package/scripts/eval-e2e.js

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+
+/**
+ * eval-e2e.js — behavioral regression eval for the epic GateEvaluator.
+ *
+ * Story onda3-s4-behavioral-eval-regression (AF-20260702 item 3.1).
+ *
+ * Two layers:
+ *
+ *   DETERMINISTIC (always runs, merge gate): replays the versioned golden set
+ *   (tests/evals/epic-gates/cases.json) against the REAL orchestration
+ *   GateEvaluator with the DEFAULT gate config pinned (repo-local overrides in
+ *   core-config.yaml never bend the baseline). Every case is a measured bug
+ *   from the 2026-06-30 checkpoints — or a control case. Any mismatch = exit 1.
+ *
+ *   LLM ARM PREFLIGHT (opt-in: --llm or SINAPSE_EVAL_LLM=1): verifies that a
+ *   `claude` binary is spawnable and prints the exact 2-arm measurement
+ *   protocol commands (tests/evals/epic-gates/PROTOCOL.md). When the spawn is
+ *   unavailable (known Windows nested-spawn limitation, KNOWN-LIMITATIONS of
+ *   epic-orchestration-consolidation) it reports EVAL_LLM_SKIPPED with the
+ *   reason — an explicit skip, never a fake pass.
+ *
+ * Usage:
+ *   npm run eval:e2e
+ *   node scripts/eval-e2e.js [--llm]
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const ROOT = path.resolve(__dirname, '..');
+const CASES_PATH = path.join(ROOT, 'tests', 'evals', 'epic-gates', 'cases.json');
+const PROTOCOL_PATH = path.join('tests', 'evals', 'epic-gates', 'PROTOCOL.md');
+
+const {
+  GateEvaluator,
+  DEFAULT_GATE_CONFIG,
+} = require(path.join(ROOT, '.sinapse-ai', 'core', 'orchestration', 'gate-evaluator'));
+
+/**
+ * Assert one golden case against a live gate result.
+ * @returns {string[]} List of mismatch descriptions (empty = pass)
+ */
+function assertCase(caseObj, result) {
+  const failures = [];
+  const expect = caseObj.expect || {};
+
+  if (expect.verdict && result.verdict !== expect.verdict) {
+    failures.push(`verdict: expected "${expect.verdict}", got "${result.verdict}"`);
+  }
+
+  if (typeof expect.scoreEquals === 'number' && Math.abs(result.score - expect.scoreEquals) > 0.01) {
+    failures.push(`score: expected ${expect.scoreEquals}, got ${result.score}`);
+  }
+
+  for (const name of expect.failedChecks || []) {
+    const check = result.checks.find((c) => c.name === name);
+    if (!check) failures.push(`failed check "${name}": not evaluated at all`);
+    else if (check.passed) failures.push(`failed check "${name}": expected FAIL, got PASS`);
+  }
+
+  for (const name of expect.passedChecks || []) {
+    const check = result.checks.find((c) => c.name === name);
+    if (!check) failures.push(`passed check "${name}": not evaluated at all`);
+    else if (!check.passed) failures.push(`passed check "${name}": expected PASS, got FAIL (${check.message})`);
+  }
+
+  for (const name of expect.issues || []) {
+    if (!result.issues.some((i) => i.check === name)) {
+      failures.push(`issue "${name}": expected present, not found`);
+    }
+  }
+
+  return failures;
+}
+
+async function runDeterministicLayer() {
+  const suite = JSON.parse(fs.readFileSync(CASES_PATH, 'utf8'));
+  console.log(`=== eval:e2e — ${suite.suite} (${suite.cases.length} cases) ===`);
+
+  let failedCases = 0;
+  for (const caseObj of suite.cases) {
+    // Fresh evaluator per case; DEFAULT config pinned so repo-local
+    // core-config.yaml overrides can never bend the behavioral baseline.
+    const evaluator = new GateEvaluator({
+      projectRoot: ROOT,
+      strictMode: Boolean(caseObj.strictMode),
+      gateConfig: DEFAULT_GATE_CONFIG,
+    });
+
+    const result = await evaluator.evaluate(caseObj.gate.from, caseObj.gate.to, caseObj.epicResult);
+    const failures = assertCase(caseObj, result);
+
+    if (failures.length === 0) {
+      console.log(`  PASS  ${caseObj.id}`);
+    } else {
+      failedCases += 1;
+      console.log(`  FAIL  ${caseObj.id}`);
+      for (const f of failures) console.log(`        - ${f}`);
+    }
+  }
+
+  console.log('');
+  if (failedCases > 0) {
+    console.log(`eval:e2e: FAIL — ${failedCases}/${suite.cases.length} behavioral case(s) regressed.`);
+    return false;
+  }
+  console.log(`eval:e2e: OK — all ${suite.cases.length} behavioral cases passed.`);
+  return true;
+}
+
+function runLlmArmPreflight() {
+  console.log('');
+  console.log('=== eval:e2e — LLM arm preflight ===');
+  try {
+    const version = execFileSync('claude', ['--version'], {
+      encoding: 'utf8',
+      timeout: 30000,
+      shell: process.platform === 'win32',
+    }).trim();
+    console.log(`claude spawnable: ${version}`);
+    console.log(`Protocolo de medição 2 braços: ${PROTOCOL_PATH}`);
+    console.log('Execute os braços conforme o protocolo e registre o scoreboard no checkpoint.');
+    return true;
+  } catch (error) {
+    console.log(`EVAL_LLM_SKIPPED: claude não spawnável daqui (${error.message.split('\n')[0]}).`);
+    console.log('Motivo conhecido no Windows: spawn aninhado falha (KNOWN-LIMITATIONS,');
+    console.log('epic-orchestration-consolidation). Rode o braço LLM via harness ou em');
+    console.log(`ambiente com spawn direto, seguindo ${PROTOCOL_PATH}.`);
+    return true; // skip explícito não é falha — mas nunca é reportado como PASS do braço
+  }
+}
+
+async function main() {
+  const wantLlm = process.argv.includes('--llm') || process.env.SINAPSE_EVAL_LLM === '1';
+
+  const deterministicOk = await runDeterministicLayer();
+  if (wantLlm) runLlmArmPreflight();
+
+  process.exit(deterministicOk ? 0 : 1);
+}
+
+main().catch((error) => {
+  console.error(`eval:e2e crashed: ${error.message}`);
+  process.exit(1);
+});

package/scripts/sinapse-patch.js

@@ -12,6 +12,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const { atomicWriteSync } = require('../.sinapse-ai/core/synapse/utils/atomic-write');
 const os = require('os');
 
 // ─────────────────────────────────────────────
@@ -228,7 +229,7 @@ if (dkyStart !== -1) {
 // ═══════════════════════════════════════════════════
 // SALVAR
 // ═══════════════════════════════════════════════════
-fs.writeFileSync(CLI_PATH, content, 'utf8');
+atomicWriteSync(CLI_PATH, content, 'utf8');
 
 console.log(`\n=== Patch aplicado com sucesso: ${changes} alteracoes ===`);
 console.log('');

package/scripts/sync-squad-yaml-components.js

@@ -33,6 +33,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const { atomicWriteSync } = require('../.sinapse-ai/core/synapse/utils/atomic-write');
 
 const ROOT = path.resolve(__dirname, '..');
 const SQUADS_DIR = path.join(ROOT, 'squads');
@@ -168,7 +169,7 @@ function processSquad(squadName) {
   }
   const block = buildComponentsBlock(agents);
   const newContent = content.trimEnd() + '\n' + block;
-  fs.writeFileSync(yamlPath, newContent, 'utf8');
+  atomicWriteSync(yamlPath, newContent, 'utf8');
   return { squadName, status: 'updated', changes: agents.length };
 }
 

package/scripts/validate-agents-md.js

@@ -27,6 +27,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const { atomicWriteSync } = require('../.sinapse-ai/core/synapse/utils/atomic-write');
 const { execSync } = require('child_process');
 
 const ROOT = path.resolve(__dirname, '..');
@@ -113,7 +114,7 @@ function main() {
   }
 
   if (FIX) {
-    fs.writeFileSync(AGENTS_MD, fixed, 'utf8');
+    atomicWriteSync(AGENTS_MD, fixed, 'utf8');
     console.log('AGENTS.md count(s) rewritten to match disk:');
     for (const mm of mismatches) console.log(`  - ${mm}`);
     process.exit(0);

package/scripts/validate-all.js

@@ -55,6 +55,9 @@ const GUARDS = [
   { name: 'squad-yaml', script: 'validate:squad-yaml' },
   { name: 'squad-orqx', script: 'validate:squad-orqx' },
   { name: 'agent-codenames', script: 'validate:agent-codenames' },
+  // Article IV traceability — WARN-only during calibration: the script itself
+  // exits 0 on orphans unless ARTICLE_IV_STRICT=1 (see validate-article-iv.js).
+  { name: 'article-iv', script: 'validate:article-iv' },
 ];
 
 /**

package/scripts/validate-article-iv.js

@@ -0,0 +1,289 @@
+#!/usr/bin/env node
+
+/**
+ * validate-article-iv.js — Constitution Article IV (No Invention) traceability check.
+ *
+ * Story onda3-s1-article-iv-traceability (AF-20260702 item 3.2).
+ *
+ * What it does (deterministic, no LLM):
+ *   1. Resolves the push range: merge-base(HEAD, origin/main)..HEAD.
+ *   2. Extracts story refs ("[Story xyz]") from commit messages in the range.
+ *   3. Locates each referenced story under docs/stories/ and extracts its
+ *      acceptance criteria ("- [ ] ACn:") and its "## File List" section.
+ *   4. Compares changed PRODUCT files against the union of the stories'
+ *      File Lists. A changed product file mapped by no story is an ORPHAN.
+ *
+ * Calibration mode (default): orphans are WARNINGS, exit 0. Pass --strict
+ * (or ARTICLE_IV_STRICT=1) to turn orphans into a failure (exit 1). The
+ * warning phase exists to calibrate the matcher before it gets teeth —
+ * mirrors the rollout the audit prescribed ("órfão começa como warning").
+ *
+ * Why this runs at pre-push and NOT in GitHub CI: docs/stories/ is local-only
+ * (gitignored by design — stories are working artifacts). CI has no stories
+ * to trace against, so the only honest home for this check is the developer
+ * machine, where the stories exist. When stories are unavailable the check
+ * reports ARTICLE_IV_SKIPPED and exits 0 — an explicit skip, never a fake pass.
+ *
+ * Usage:
+ *   npm run validate:article-iv
+ *   node scripts/validate-article-iv.js [--strict] [--base <ref>]
+ */
+
+'use strict';
+
+const { execFileSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = path.resolve(__dirname, '..');
+
+// Prefixes that count as product surface for traceability purposes.
+// Aligned with enforce-story-gate.cjs CODE_PATHS plus the framework tree
+// (.sinapse-ai) and scripts/, which are product in this repo.
+const PRODUCT_PREFIXES = [
+  'packages/',
+  'src/',
+  'app/',
+  'lib/',
+  'bin/',
+  'components/',
+  'pages/',
+  'api/',
+  'services/',
+  'scripts/',
+  '.sinapse-ai/',
+];
+
+// Never traced: docs, tests, mirrors, CI plumbing and generated artifacts —
+// they either have their own governance or are regenerated mechanically.
+const EXCLUDED_PREFIXES = [
+  'docs/',
+  'tests/',
+  '.claude/',
+  '.codex/',
+  '.github/',
+  'audits/',
+  'governance/',
+];
+
+const GENERATED_FILES = [
+  '.sinapse-ai/install-manifest.yaml',
+  '.sinapse-ai/data/entity-registry.yaml',
+  '.sinapse-ai/manifests/agents.csv',
+  '.sinapse-ai/manifests/workers.csv',
+  '.sinapse-ai/manifests/tasks.csv',
+];
+
+const STORY_REF_RE = /\[story\s+([^\]]+)\]/gi;
+const AC_RE = /^- \[( |x)\] (AC\d+):\s*(.*)$/gim;
+
+/** Extract unique story refs ("[Story 2.1]" → "2.1") from free text. */
+function extractStoryRefs(text) {
+  const refs = new Set();
+  let m;
+  STORY_REF_RE.lastIndex = 0;
+  while ((m = STORY_REF_RE.exec(text)) !== null) {
+    const ref = m[1].trim();
+    if (ref) refs.add(ref);
+  }
+  return [...refs];
+}
+
+/** Extract acceptance criteria from story markdown. */
+function extractAcceptanceCriteria(storyContent) {
+  const acs = [];
+  let m;
+  AC_RE.lastIndex = 0;
+  while ((m = AC_RE.exec(storyContent)) !== null) {
+    acs.push({ id: m[2].toUpperCase(), checked: m[1] === 'x', text: m[3].trim() });
+  }
+  return acs;
+}
+
+/**
+ * Extract path-ish entries from the story's "## File List" section.
+ * Accepts list items like "- path/to/file.js (novo)" — the first
+ * whitespace-delimited token of each bullet is taken as the path.
+ */
+function extractFileList(storyContent) {
+  const lines = storyContent.split(/\r?\n/);
+  const entries = [];
+  let inSection = false;
+  for (const line of lines) {
+    if (/^##\s+file list\s*$/i.test(line.trim())) {
+      inSection = true;
+      continue;
+    }
+    if (inSection && /^##\s+/.test(line.trim())) break;
+    if (!inSection) continue;
+    const bullet = line.trim().match(/^[-*]\s+(.*)$/);
+    if (!bullet) continue;
+    const token = bullet[1].trim().split(/\s+/)[0];
+    if (token) entries.push(token.replace(/\\/g, '/').replace(/[,;]$/, ''));
+  }
+  return entries;
+}
+
+/** True when a changed path counts as traceable product surface. */
+function isProductFile(rel) {
+  const norm = rel.replace(/\\/g, '/');
+  if (GENERATED_FILES.includes(norm)) return false;
+  if (EXCLUDED_PREFIXES.some((p) => norm.startsWith(p))) return false;
+  return PRODUCT_PREFIXES.some((p) => norm.startsWith(p));
+}
+
+/**
+ * Match changed product files against File List entries.
+ * A file is mapped when some entry equals it, is a prefix directory of it,
+ * or the file path ends with the entry (tolerates entries written relative).
+ */
+function matchFilesToStory(changedProductFiles, fileListEntries) {
+  const norm = (s) => s.replace(/\\/g, '/').toLowerCase();
+  const entries = fileListEntries.map(norm);
+  const mapped = [];
+  const orphans = [];
+  for (const file of changedProductFiles) {
+    const f = norm(file);
+    const hit = entries.some(
+      (e) => e === f || f.startsWith(e.endsWith('/') ? e : `${e}/`) || f.endsWith(e),
+    );
+    (hit ? mapped : orphans).push(file);
+  }
+  return { mapped, orphans };
+}
+
+/** Recursively collect .md files under a directory. */
+function walkMarkdown(dir) {
+  const out = [];
+  let items = [];
+  try {
+    items = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const item of items) {
+    const full = path.join(dir, item.name);
+    if (item.isDirectory()) out.push(...walkMarkdown(full));
+    else if (item.name.endsWith('.md')) out.push(full);
+  }
+  return out;
+}
+
+/**
+ * Find the story file for a ref: filename containing the slugged ref, or
+ * story content containing the literal "[Story <ref>]".
+ */
+function findStoryFile(storiesDir, ref) {
+  const slug = ref.toLowerCase().replace(/\s+/g, '-');
+  const files = walkMarkdown(storiesDir);
+  for (const file of files) {
+    const base = path.basename(file, '.md').toLowerCase();
+    if (base.includes(slug)) return file;
+  }
+  const needle = `[story ${ref.toLowerCase()}]`;
+  for (const file of files) {
+    try {
+      if (fs.readFileSync(file, 'utf8').toLowerCase().includes(needle)) return file;
+    } catch {
+      /* unreadable file — keep scanning */
+    }
+  }
+  return null;
+}
+
+function git(args) {
+  return execFileSync('git', args, { cwd: ROOT, encoding: 'utf8' });
+}
+
+function main() {
+  const argv = process.argv.slice(2);
+  const strict = argv.includes('--strict') || process.env.ARTICLE_IV_STRICT === '1';
+  const baseIdx = argv.indexOf('--base');
+  const baseRef = baseIdx !== -1 ? argv[baseIdx + 1] : process.env.ARTICLE_IV_BASE || 'origin/main';
+
+  let mergeBase;
+  try {
+    mergeBase = git(['merge-base', 'HEAD', baseRef]).trim();
+  } catch {
+    console.log(`ARTICLE_IV_SKIPPED: cannot resolve merge-base with ${baseRef} (no remote?).`);
+    process.exit(0);
+  }
+
+  const changed = git(['diff', '--name-only', `${mergeBase}..HEAD`])
+    .split(/\r?\n/)
+    .filter(Boolean);
+  const commitText = git(['log', '--format=%B', `${mergeBase}..HEAD`]);
+
+  const refs = extractStoryRefs(commitText);
+  if (refs.length === 0) {
+    console.log('article-iv: no story refs in push range — nothing to trace.');
+    process.exit(0);
+  }
+
+  const storiesDir = path.join(ROOT, 'docs', 'stories');
+  if (!fs.existsSync(storiesDir)) {
+    console.log('ARTICLE_IV_SKIPPED: docs/stories unavailable (local-only artifact).');
+    process.exit(0);
+  }
+
+  const fileListUnion = [];
+  const foundStories = [];
+  const missingRefs = [];
+  for (const ref of refs) {
+    const storyFile = findStoryFile(storiesDir, ref);
+    if (!storyFile) {
+      missingRefs.push(ref);
+      continue;
+    }
+    const content = fs.readFileSync(storyFile, 'utf8');
+    foundStories.push({ ref, file: path.relative(ROOT, storyFile), acs: extractAcceptanceCriteria(content).length });
+    fileListUnion.push(...extractFileList(content));
+  }
+
+  if (foundStories.length === 0) {
+    console.log(
+      `ARTICLE_IV_SKIPPED: no referenced story found locally (refs: ${refs.join(', ')}).`,
+    );
+    process.exit(0);
+  }
+
+  const productChanged = changed.filter(isProductFile);
+  const { mapped, orphans } = matchFilesToStory(productChanged, fileListUnion);
+
+  console.log('=== article-iv traceability ===');
+  for (const s of foundStories) {
+    console.log(`story [${s.ref}] -> ${s.file} (${s.acs} ACs)`);
+  }
+  if (missingRefs.length) {
+    console.log(`refs without local story (skipped): ${missingRefs.join(', ')}`);
+  }
+  console.log(`product files changed: ${productChanged.length} | mapped: ${mapped.length} | orphans: ${orphans.length}`);
+
+  if (orphans.length > 0) {
+    console.log('');
+    console.log('ORPHAN product files (changed but absent from every referenced File List):');
+    for (const f of orphans) console.log(`  WARN  ${f}`);
+    console.log('');
+    console.log('Fix: add the file to the story\'s "## File List", or move the change to its own story.');
+    if (strict) {
+      console.log('article-iv: FAIL (strict mode).');
+      process.exit(1);
+    }
+    console.log('article-iv: WARN-only (calibration mode) — not blocking.');
+    process.exit(0);
+  }
+
+  console.log('article-iv: OK — full traceability.');
+  process.exit(0);
+}
+
+module.exports = {
+  extractStoryRefs,
+  extractAcceptanceCriteria,
+  extractFileList,
+  isProductFile,
+  matchFilesToStory,
+  findStoryFile,
+};
+
+if (require.main === module) main();

package/scripts/validate-article-xi.js

@@ -31,7 +31,7 @@
 'use strict';
 
 const path = require('path');
-const { execSync } = require('child_process');
+const { execFileSync } = require('child_process');
 
 const ROOT = path.resolve(__dirname, '..');
 
@@ -61,9 +61,11 @@ function getBaseRef(args) {
   return 'main';
 }
 
-function gitExec(cmd) {
+// SECURITY: args go straight to git without a shell — baseRef comes from CLI
+// or GITHUB_BASE_REF and must never be interpolated into a shell string.
+function gitExec(args) {
   try {
-    return execSync(cmd, { cwd: ROOT, stdio: ['ignore', 'pipe', 'pipe'] }).toString();
+    return execFileSync('git', args, { cwd: ROOT, stdio: ['ignore', 'pipe', 'pipe'] }).toString();
   } catch (_err) {
     return null;
   }
@@ -78,14 +80,14 @@ function gitExec(cmd) {
  */
 function diffAgainstBase(baseRef) {
   // Try fetching first (CI may need it). Silent if it fails.
-  gitExec(`git fetch origin ${baseRef} --quiet`);
+  gitExec(['fetch', 'origin', baseRef, '--quiet']);
 
   // Use raw diff with --name-status -M (rename detection).
   const tripleDot = `origin/${baseRef}...HEAD`;
-  let raw = gitExec(`git diff --name-status -M ${tripleDot}`);
+  let raw = gitExec(['diff', '--name-status', '-M', tripleDot]);
   if (raw === null) {
     // Fallback: local base ref
-    raw = gitExec(`git diff --name-status -M ${baseRef}...HEAD`);
+    raw = gitExec(['diff', '--name-status', '-M', `${baseRef}...HEAD`]);
   }
   if (raw === null) {
     return { error: `nao foi possivel comparar com ${baseRef}`, deletions: [], renames: [] };
@@ -110,8 +112,8 @@ function diffAgainstBase(baseRef) {
 
 function getOverrideText(baseRef) {
   // Aggregate commit messages between base..HEAD + PR body.
-  const commitMsgs = gitExec(`git log --format=%B origin/${baseRef}..HEAD`)
-    || gitExec(`git log --format=%B ${baseRef}..HEAD`)
+  const commitMsgs = gitExec(['log', '--format=%B', `origin/${baseRef}..HEAD`])
+    || gitExec(['log', '--format=%B', `${baseRef}..HEAD`])
     || '';
   const prBody = process.env.GITHUB_PR_BODY || '';
   const forcedOverride = process.env.ARTICLE_XI_OVERRIDE || '';

package/scripts/validate-evals.js

@@ -146,7 +146,14 @@ function isPlainObject(v) {
   return v !== null && typeof v === 'object' && !Array.isArray(v);
 }
 
-/** Discover gate folders under tests/evals/ (every dir except _lib / _*). */
+/**
+ * Suites that follow their OWN contract (not the IDS evals.json/triggers.json
+ * one) and have their own runner + jest wrapper. Onda3-S4: epic-gates uses
+ * cases.json validated by scripts/eval-e2e.js.
+ */
+const NON_IDS_SUITES = new Set(['epic-gates']);
+
+/** Discover gate folders under tests/evals/ (every dir except _lib / _* / non-IDS suites). */
 function discoverGateDirs() {
   let entries;
   try {
@@ -156,7 +163,7 @@ function discoverGateDirs() {
     process.exit(2);
   }
   return entries
-    .filter((d) => d.isDirectory() && !d.name.startsWith('_'))
+    .filter((d) => d.isDirectory() && !d.name.startsWith('_') && !NON_IDS_SUITES.has(d.name))
     .map((d) => path.join(EVALS_ROOT, d.name))
     .sort();
 }

package/scripts/validate-no-external-refs.js

@@ -240,21 +240,27 @@ function isBinaryFile(absPath) {
 function scanFile(rootDir, relPath) {
   if (isAllowListed(relPath)) return [];
   const absPath = path.join(rootDir, relPath);
-  let stat;
+
+  // Size cap and read share one fd, so the scanned bytes are the sized bytes.
+  let content;
+  let fd;
   try {
-    stat = fs.statSync(absPath);
+    fd = fs.openSync(absPath, 'r');
   } catch {
     return [];
   }
-  if (!stat.isFile()) return [];
-  if (stat.size > MAX_SCAN_BYTES) return [];
-  if (isBinaryFile(absPath)) return [];
-
-  let content;
   try {
-    content = fs.readFileSync(absPath, 'utf8');
+    const stat = fs.fstatSync(fd);
+    if (!stat.isFile()) return [];
+    if (stat.size > MAX_SCAN_BYTES) return [];
+    if (isBinaryFile(absPath)) return [];
+    const buf = Buffer.alloc(stat.size);
+    fs.readSync(fd, buf, 0, stat.size, 0);
+    content = buf.toString('utf8');
   } catch {
     return [];
+  } finally {
+    fs.closeSync(fd);
   }
 
   const lines = content.split(/\r?\n/);