@geraldmaron/construct 1.1.1 → 1.2.0

package/lib/install/desktop-binary-download.mjs

@@ -0,0 +1,85 @@
+/**
+ * lib/install/desktop-binary-download.mjs — downloads the Construct chat desktop binary.
+ *
+ * Fetches the platform-matching construct-chat binary from the latest GitHub
+ * release and writes it to ~/.construct/bin/. Called by `construct install --scope=user`.
+ * Network failures are non-fatal: returns { status: 'skipped', reason } so the
+ * rest of setup can proceed without the desktop binary.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+const GITHUB_REPO = 'geraldmaron/construct';
+
+function assetName() {
+  const plat = process.platform;
+  const arch = process.arch === 'arm64' ? 'arm64' : 'x64';
+  if (plat === 'win32') return 'construct-chat-windows-x64.exe';
+  if (plat === 'darwin') return `construct-chat-darwin-${arch}`;
+  return `construct-chat-linux-${arch}`;
+}
+
+function destBinaryName() {
+  return process.platform === 'win32' ? 'construct-chat.exe' : 'construct-chat';
+}
+
+async function fetchRelease(env) {
+  const headers = { 'User-Agent': 'construct-installer/1.0' };
+  if (env.GITHUB_TOKEN) headers['Authorization'] = `Bearer ${env.GITHUB_TOKEN}`;
+  const res = await fetch(`https://api.github.com/repos/${GITHUB_REPO}/releases/latest`, { headers });
+  if (!res.ok) throw new Error(`GitHub API ${res.status}: ${await res.text().then((t) => t.slice(0, 120))}`);
+  return res.json();
+}
+
+async function downloadAsset(url, dest, env) {
+  const headers = {
+    'User-Agent': 'construct-installer/1.0',
+    'Accept': 'application/octet-stream',
+  };
+  if (env.GITHUB_TOKEN) headers['Authorization'] = `Bearer ${env.GITHUB_TOKEN}`;
+  const res = await fetch(url, { headers, redirect: 'follow' });
+  if (!res.ok) throw new Error(`Download ${res.status}: ${url}`);
+  const buf = await res.arrayBuffer();
+  fs.writeFileSync(dest, Buffer.from(buf));
+}
+
+// Returns { status: 'downloaded'|'skipped'|'failed' }; 'skipped' and 'failed' are both non-fatal.
+export async function downloadDesktopBinary({ homeDir, env = process.env } = {}) {
+  const binDir = path.join(homeDir, '.construct', 'bin');
+  const dest = path.join(binDir, destBinaryName());
+  const name = assetName();
+
+  let release;
+  try {
+    release = await fetchRelease(env);
+  } catch (err) {
+    return { status: 'skipped', reason: `GitHub API unreachable: ${err.message}` };
+  }
+
+  const asset = release.assets?.find((a) => a.name === name);
+  if (!asset) {
+    return {
+      status: 'skipped',
+      reason: `No desktop binary in ${release.tag_name} for this platform (looked for ${name})`,
+    };
+  }
+
+  fs.mkdirSync(binDir, { recursive: true });
+
+  try {
+    await downloadAsset(asset.browser_download_url, dest, env);
+  } catch (err) {
+    return { status: 'failed', reason: err.message };
+  }
+
+  if (process.platform !== 'win32') {
+    try {
+      fs.chmodSync(dest, 0o755);
+    } catch {
+      /* best effort */
+    }
+  }
+
+  return { status: 'downloaded', dest, version: release.tag_name };
+}

package/lib/install/legacy-global-cleanup.mjs

@@ -0,0 +1,189 @@
+/**
+ * Removes pre-project-scope Construct footprints from user-global tool config.
+ *
+ * Opt-in only: strips legacy ambient adapters/MCP/state that can slow unrelated
+ * Claude/Codex/OpenCode sessions, but never uninstalls a current global
+ * `construct` CLI package.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { removeTomlTables, tomlString } from '../codex-config.mjs';
+
+const CONSTRUCT_MCP_KEYS = ['memory', 'cass', 'construct-mcp'];
+
+function exists(p) {
+  try { fs.statSync(p); return true; } catch { return false; }
+}
+
+function rm(p, { dryRun, removed, label }) {
+  if (!exists(p)) return false;
+  removed.push(label || p);
+  if (!dryRun) fs.rmSync(p, { recursive: true, force: true });
+  return true;
+}
+
+function readJson(filePath) {
+  if (!exists(filePath)) return null;
+  try { return JSON.parse(fs.readFileSync(filePath, 'utf8')); } catch { return null; }
+}
+
+function writeJson(filePath, value, { dryRun, removed, label }) {
+  removed.push(label || filePath);
+  if (!dryRun) fs.writeFileSync(filePath, JSON.stringify(value, null, 2) + '\n', 'utf8');
+}
+
+function hasConstructText(value) {
+  return /construct|\.cx|\.construct/i.test(JSON.stringify(value ?? ''));
+}
+
+function stripClaudeSettings(homeDir, opts) {
+  const filePath = path.join(homeDir, '.claude', 'settings.json');
+  const settings = readJson(filePath);
+  if (!settings || typeof settings !== 'object') return;
+  let changed = false;
+
+  if (settings.hooks && hasConstructText(settings.hooks)) {
+    delete settings.hooks;
+    changed = true;
+  }
+
+  if (settings.mcpServers && typeof settings.mcpServers === 'object') {
+    for (const key of CONSTRUCT_MCP_KEYS) {
+      if (key in settings.mcpServers) {
+        delete settings.mcpServers[key];
+        changed = true;
+      }
+    }
+    if (Object.keys(settings.mcpServers).length === 0) delete settings.mcpServers;
+  }
+
+  if (changed) writeJson(filePath, settings, { ...opts, label: '~/.claude/settings.json Construct entries' });
+}
+
+function stripOpenCode(homeDir, opts) {
+  const filePath = path.join(homeDir, '.config', 'opencode', 'opencode.json');
+  const config = readJson(filePath);
+  if (!config || typeof config !== 'object') return;
+  let changed = false;
+
+  if (config.agent?.construct) {
+    delete config.agent.construct;
+    changed = true;
+    if (Object.keys(config.agent).length === 0) delete config.agent;
+  }
+
+  if (config.mcp && typeof config.mcp === 'object') {
+    for (const key of CONSTRUCT_MCP_KEYS) {
+      if (key in config.mcp) {
+        delete config.mcp[key];
+        changed = true;
+      }
+    }
+    if (Object.keys(config.mcp).length === 0) delete config.mcp;
+  }
+
+  if (Array.isArray(config.plugin)) {
+    const next = config.plugin.filter((entry) => !/construct/i.test(String(entry)));
+    if (next.length !== config.plugin.length) {
+      config.plugin = next;
+      changed = true;
+    }
+    if (config.plugin.length === 0) delete config.plugin;
+  }
+
+  if (changed) writeJson(filePath, config, { ...opts, label: '~/.config/opencode/opencode.json Construct entries' });
+}
+
+function stripVsCode(homeDir, opts) {
+  const userDir = path.join(homeDir, 'Library', 'Application Support', 'Code', 'User');
+  const mcpPath = path.join(userDir, 'mcp.json');
+  const mcp = readJson(mcpPath);
+  if (mcp?.servers && typeof mcp.servers === 'object') {
+    let changed = false;
+    for (const key of CONSTRUCT_MCP_KEYS) {
+      if (key in mcp.servers) {
+        delete mcp.servers[key];
+        changed = true;
+      }
+    }
+    if (changed) writeJson(mcpPath, mcp, { ...opts, label: 'VS Code mcp.json Construct servers' });
+  }
+
+  const settingsPath = path.join(userDir, 'settings.json');
+  const settings = readJson(settingsPath);
+  const copilotServers = settings?.['github.copilot.mcpServers'];
+  if (copilotServers && typeof copilotServers === 'object') {
+    let changed = false;
+    for (const key of CONSTRUCT_MCP_KEYS) {
+      if (key in copilotServers) {
+        delete copilotServers[key];
+        changed = true;
+      }
+    }
+    if (Object.keys(copilotServers).length === 0) delete settings['github.copilot.mcpServers'];
+    if (changed) writeJson(settingsPath, settings, { ...opts, label: 'VS Code settings.json Construct Copilot MCP servers' });
+  }
+}
+
+function stripCodex(homeDir, opts) {
+  const filePath = path.join(homeDir, '.codex', 'config.toml');
+  if (!exists(filePath)) return;
+  const existing = fs.readFileSync(filePath, 'utf8');
+  let next = existing
+    .replace(/\n?# BEGIN CONSTRUCT MCP SERVERS[\s\S]*?(?=\n# END CONSTRUCT MCP SERVERS\n)/g, '\n')
+    .replace(/\n# END CONSTRUCT MCP SERVERS\n?/g, '\n')
+    .replace(/\n?# BEGIN CONSTRUCT AGENTS[\s\S]*?(?=\n# END CONSTRUCT AGENTS\n)/g, '\n')
+    .replace(/\n# END CONSTRUCT AGENTS\n?/g, '\n');
+  const tables = [
+    ...CONSTRUCT_MCP_KEYS.flatMap((key) => [`mcp_servers.${key}`, `mcp_servers.${tomlString(key)}`]),
+    'agents.construct',
+    `agents.${tomlString('construct')}`,
+  ];
+  next = removeTomlTables(next, tables);
+  if (next.trimEnd() === existing.trimEnd()) return;
+  opts.removed.push('~/.codex/config.toml Construct tables');
+  if (!opts.dryRun) fs.writeFileSync(filePath, `${next.trimEnd()}\n`, 'utf8');
+}
+
+function rmConstructNamedChildren(dir, opts, labelPrefix) {
+  if (!exists(dir)) return;
+  for (const entry of fs.readdirSync(dir)) {
+    if (/construct/i.test(entry)) rm(path.join(dir, entry), { ...opts, label: `${labelPrefix}/${entry}` });
+  }
+}
+
+export function cleanupLegacyGlobalConstruct({ homeDir, dryRun = false } = {}) {
+  const removed = [];
+  const opts = { dryRun, removed };
+
+  rm(path.join(homeDir, '.construct'), { ...opts, label: '~/.construct' });
+  rm(path.join(homeDir, '.local', 'share', 'construct'), { ...opts, label: '~/.local/share/construct' });
+  rm(path.join(homeDir, 'Library', 'LaunchAgents', 'dev.construct.pressure-release.plist'), {
+    ...opts,
+    label: 'Construct pressure-release LaunchAgent',
+  });
+
+  rm(path.join(homeDir, '.github', 'prompts', 'construct.prompt.md'), { ...opts, label: '~/.github/prompts/construct.prompt.md' });
+  rm(path.join(homeDir, '.github', 'prompts', '.construct-manifest'), { ...opts, label: '~/.github/prompts/.construct-manifest' });
+  rm(path.join(homeDir, '.config', 'opencode', 'plugin', 'construct-fallback.js'), {
+    ...opts,
+    label: '~/.config/opencode/plugin/construct-fallback.js',
+  });
+
+  stripClaudeSettings(homeDir, opts);
+  stripOpenCode(homeDir, opts);
+  stripVsCode(homeDir, opts);
+  stripCodex(homeDir, opts);
+
+  rmConstructNamedChildren(path.join(homeDir, '.claude', 'projects'), opts, '~/.claude/projects');
+  rmConstructNamedChildren(path.join(homeDir, '.claude', 'plans'), opts, '~/.claude/plans');
+  rmConstructNamedChildren(path.join(homeDir, '.cursor', 'projects'), opts, '~/.cursor/projects');
+  rmConstructNamedChildren(path.join(homeDir, '.cursor', 'plans'), opts, '~/.cursor/plans');
+  rm(path.join(homeDir, '.gemini', 'history', 'construct'), { ...opts, label: '~/.gemini/history/construct' });
+  rm(path.join(homeDir, '.gemini', 'tmp', 'construct'), { ...opts, label: '~/.gemini/tmp/construct' });
+  rmConstructNamedChildren(path.join(homeDir, 'Library', 'Caches', 'claude-cli-nodejs'), opts, 'Claude cache');
+
+  return { removed, dryRun };
+}

package/lib/intake/daemon.mjs

@@ -15,6 +15,7 @@ import { join, basename } from 'node:path';
 import { homedir } from 'node:os';
 
 import { createDaemon, classifyPacket } from '../daemons/contract.mjs';
+import { memoryCapMbFor } from '../resources/process-budget.mjs';
 
 const KILLSWITCH_ENV = 'CONSTRUCT_INTAKE_DAEMON';
 
@@ -107,6 +108,7 @@ export function buildIntakeDaemon({ cwd = process.cwd(), intervalMs = 60_000, cl
     heartbeatPath: heartbeatPath(),
     maxRuntimeMs: 24 * 60 * 60 * 1000,
     maxIdleTicks: 6,
+    memoryCapMb: memoryCapMbFor('intake', cwd),
     async tick() {
       const files = listInboxFiles(cwd);
       if (files.length === 0) return { didWork: false };

package/lib/intake/git-queue.mjs

@@ -1,9 +1,8 @@
 /**
  * lib/intake/git-queue.mjs — Git-backed adapter for the IntakeQueue interface.
  *
- * This implementation replaces the PostgresIntakeQueue for team/enterprise
- * modes. It uses the filesystem and Git for state synchronization and
- * conflict resolution, removing the dependency on a central database server.
+ * Backs team/enterprise modes with the filesystem and Git for state
+ * synchronization and conflict resolution, with no central database server.
  *
  * Structure:
  * .cx/team-inbox/
@@ -111,7 +110,8 @@ export class GitIntakeQueue {
   async claim({ claimedBy }) {
     if (!claimedBy) throw new Error('claim: claimedBy is required');
     
-    // 1. Pull latest to minimize conflicts
+    // Pull latest to minimize conflicts
+
     try { execSync('git pull --rebase', { stdio: 'ignore' }); } catch (e) {}
 
     const pendingDir = path.join(this.inboxRoot, 'pending');
@@ -136,16 +136,17 @@ export class GitIntakeQueue {
       data.claimedAt = new Date().toISOString();
       fs.writeFileSync(claimedPath, JSON.stringify(data, null, 2));
 
-      // 2. Commit and Push
+      // Commit and push the claim so peers see it
+
       execSync(`git add .cx/team-inbox/pending/${fileName} .cx/team-inbox/claimed/${claimedBy}/${fileName}`, { stdio: 'ignore' });
       execSync(`git commit -m "Claim task ${data.id} by ${claimedBy}"`, { stdio: 'ignore' });
       execSync('git push', { stdio: 'ignore' });
 
       return data;
     } catch (err) {
-      // If push fails, someone else probably claimed it first or Git is out of sync.
-      // We should ideally rollback the local move, but for this first pass
-      // we'll let the next 'git pull --rebase' fix the state.
+      // A push failure means another worker claimed it first or Git is out of
+      // sync; the local move is left for the next 'git pull --rebase' to reconcile.
+
       console.error(`Failed to claim ${fileName}: ${err.message}`);
       return null;
     }

package/lib/intake/queue.mjs

@@ -68,7 +68,8 @@ export function createIntakeQueue(rootDir, env = process.env, opts = {}) {
   const backend = opts.backend || resolveBackend(env);
   if (backend === 'filesystem') return new FilesystemIntakeQueue(rootDir);
   if (backend === 'git' || backend === 'postgres') {
-    // We treat 'postgres' as an alias for 'git' now to avoid breaking existing configs
+    // 'postgres' aliases to 'git' so existing configs keep resolving
+
     const project = opts.project ?? resolveProject(rootDir, env);
     return new GitIntakeQueue({ project, rootDir });
   }

package/lib/intake/session-prelude.mjs

@@ -14,6 +14,11 @@ import { createIntakeQueue } from './queue.mjs';
 import { formatTriageLine } from './classify.mjs';
 import { isBrokered } from '../mcp/broker.mjs';
 import { getRebrand } from '../profiles/rebrand.mjs';
+import { homedir as osHomedir } from 'node:os';
+import { readLastTick } from '../oracle/index.mjs';
+import { listPending } from '../oracle/actions.mjs';
+import { readLatestVerdict } from '../oracle/verdicts.mjs';
+import { isVerdictOnlyGap } from '../oracle/policy.mjs';
 
 export function buildIntakePrelude({ cwd, env = process.env } = {}) {
   if (!cwd) return '';
@@ -48,9 +53,93 @@ export function buildBrokerStatusLine({ env = process.env } = {}) {
 export function buildSessionPrelude({ cwd, env = process.env } = {}) {
   const intake = buildIntakePrelude({ cwd, env });
   const broker = buildBrokerStatusLine({ env });
-  if (!intake && !broker) return '';
+  const oracle = buildOraclePrelude({ cwd, env });
+  if (!intake && !broker && !oracle) return '';
   const parts = [];
   if (intake) parts.push(intake.trim());
+  if (oracle) parts.push(oracle.trim());
   if (broker) parts.push(broker);
   return parts.join('\n\n');
 }
+
+/**
+ * Oracle verdict + pending queue for session-start (mirror doctor warnings).
+ */
+export function buildOraclePrelude({ cwd, env = process.env, homeDir } = {}) {
+  if (!cwd) return '';
+  if (env.CONSTRUCT_ORACLE === 'off' || env.CONSTRUCT_ORACLE === '0') return '';
+  try {
+    const home = homeDir ?? osHomedir();
+    const last = readLastTick(home);
+    const verdict = readLatestVerdict(cwd);
+    const pending = listPending(cwd).filter((p) => p.status === 'pending');
+    const v = verdict?.verdict ?? last?.verdict ?? 'unknown';
+    if (v === 'healthy' && pending.length === 0) return '';
+    const lines = [`\n## Oracle overseer · verdict: **${v}**`];
+    const gapSource = verdict?.gaps ?? last?.gaps ?? [];
+    const top = gapSource.filter((g) => g.severity === 'high').slice(0, 3);
+    for (const g of top) {
+      if (isVerdictOnlyGap(g)) {
+        const hint = g.id === 'beads-hygiene'
+          ? 'run `construct beads drift`'
+          : g.id === 'workflow-misaligned'
+            ? 'run `construct workflow init` or `construct init`'
+            : 'see `construct oracle gaps`';
+        lines.push(`- [${g.severity}] ${g.id} (verdict-only): ${g.detail} — ${hint}`);
+      } else {
+        lines.push(`- [${g.severity}] ${g.id}: ${g.detail}`);
+      }
+    }
+    if (pending.length) {
+      lines.push(`Pending approvals (${pending.length}): \`construct oracle pending\``);
+    }
+    lines.push('Review: `construct oracle review` · Gaps: `construct oracle gaps` · Approve: `construct oracle approve <id>`\n');
+    return lines.join('\n');
+  } catch {
+    return '';
+  }
+}
+
+export function readOracleDockState({ cwd, env = process.env, homeDir } = {}) {
+  if (!cwd || env.CONSTRUCT_ORACLE === 'off' || env.CONSTRUCT_ORACLE === '0') {
+    return { visible: false, verdict: null, pendingCount: 0, topGaps: [], summary: '' };
+  }
+  try {
+    const home = homeDir ?? osHomedir();
+    const last = readLastTick(home);
+    const verdictDoc = readLatestVerdict(cwd);
+    const pending = listPending(cwd).filter((p) => p.status === 'pending');
+    const verdict = verdictDoc?.verdict ?? last?.verdict ?? 'unknown';
+    const gapSource = verdictDoc?.gaps ?? last?.gaps ?? [];
+    const topGaps = gapSource.filter((g) => g.severity === 'high').slice(0, 3);
+    const visible = verdict !== 'healthy' || pending.length > 0;
+    const parts = [`verdict ${verdict}`];
+    if (pending.length) parts.push(`${pending.length} pending`);
+    return {
+      visible,
+      verdict,
+      pendingCount: pending.length,
+      topGaps,
+      summary: parts.join(' · '),
+    };
+  } catch {
+    return { visible: false, verdict: null, pendingCount: 0, topGaps: [], summary: '' };
+  }
+}
+
+export function formatOracleDockDetail(state) {
+  if (!state?.visible) return 'Oracle: healthy — no pending approvals.';
+  const lines = [`Oracle overseer · ${state.summary}`];
+  for (const g of state.topGaps || []) {
+    if (isVerdictOnlyGap(g)) {
+      lines.push(`  [${g.severity}] ${g.id} (verdict-only): ${g.detail}`);
+    } else {
+      lines.push(`  [${g.severity}] ${g.id}: ${g.detail}`);
+    }
+  }
+  if (state.pendingCount > 0) {
+    lines.push('  Pending: construct oracle pending');
+  }
+  lines.push('  Review: construct oracle review · Gaps: construct oracle gaps');
+  return lines.join('\n');
+}

package/lib/libreoffice-export.mjs

@@ -0,0 +1,97 @@
+/**
+ * lib/libreoffice-export.mjs — LibreOffice headless conversion for legacy .doc export.
+ *
+ * Pandoc has no `.doc` writer; Construct exports DOCX first, then down-converts via
+ * `soffice --headless --convert-to doc`. Binary is optional (ADR-0024).
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+const SOFFICE_CANDIDATES = [
+  'soffice',
+  'libreoffice',
+  '/Applications/LibreOffice.app/Contents/MacOS/soffice',
+];
+
+function whichBin(name) {
+  const cmd = process.platform === 'win32' ? 'where' : 'which';
+  const result = spawnSync(cmd, [name], { encoding: 'utf8' });
+  if (result.status !== 0) return null;
+  return (result.stdout || '').trim().split('\n')[0] || null;
+}
+
+export function resolveLibreOfficeBin(env = process.env) {
+  const fromEnv = (env.CONSTRUCT_LIBREOFFICE_BIN || env.SOFFICE_BIN || '').trim();
+  if (fromEnv && fs.existsSync(fromEnv)) return fromEnv;
+  for (const candidate of SOFFICE_CANDIDATES) {
+    if (candidate.includes('/') && fs.existsSync(candidate)) return candidate;
+    const found = whichBin(candidate);
+    if (found) return found;
+  }
+  return null;
+}
+
+export function libreOfficePresent(env = process.env) {
+  return Boolean(resolveLibreOfficeBin(env));
+}
+
+export function libreOfficeInstallHint() {
+  return 'Install LibreOffice to enable legacy .doc export (e.g. `brew install --cask libreoffice` on macOS, `apt install libreoffice` on Debian/Ubuntu, or https://www.libreoffice.org/download/). Override with CONSTRUCT_LIBREOFFICE_BIN.';
+}
+
+export function convertDocxToDoc({
+  docxPath,
+  outputPath,
+  env = process.env,
+  spawnFn = spawnSync,
+} = {}) {
+  const soffice = resolveLibreOfficeBin(env);
+  if (!soffice) {
+    return {
+      ok: false,
+      message: libreOfficeInstallHint(),
+      missing: ['libreoffice'],
+    };
+  }
+  if (!fs.existsSync(docxPath)) {
+    return { ok: false, message: `DOCX intermediate missing: ${docxPath}` };
+  }
+
+  const outDir = path.dirname(outputPath);
+  fs.mkdirSync(outDir, { recursive: true });
+
+  const result = spawnFn(soffice, [
+    '--headless',
+    '--convert-to', 'doc',
+    '--outdir', outDir,
+    path.resolve(docxPath),
+  ], { encoding: 'utf8', env });
+
+  if (result.status !== 0) {
+    return {
+      ok: false,
+      message: `LibreOffice conversion failed (exit ${result.status}): ${(result.stderr || result.stdout || '').trim().slice(0, 400)}`,
+    };
+  }
+
+  const expected = path.join(outDir, `${path.parse(docxPath).name}.doc`);
+  if (!fs.existsSync(expected)) {
+    return {
+      ok: false,
+      message: `LibreOffice did not produce expected output: ${expected}`,
+    };
+  }
+
+  if (path.resolve(expected) !== path.resolve(outputPath)) {
+    fs.renameSync(expected, outputPath);
+  }
+
+  return {
+    ok: true,
+    outputPath,
+    engine: 'libreoffice',
+    message: `Wrote ${path.relative(process.cwd(), outputPath)}`,
+  };
+}

package/lib/logging/rotate.mjs

@@ -231,6 +231,15 @@ export const LIMITS = {
     envOverride: 'CONSTRUCT_HOOK_CALLS_MAX_MB',
   },
 
+  // Rule path reference telemetry. ~/.cx/rule-calls.jsonl.
+
+  'rule-calls': {
+    maxBytes: 10 * 1024 * 1024,
+    maxSegments: 2,
+    gzip: true,
+    envOverride: 'CONSTRUCT_RULE_CALLS_MAX_MB',
+  },
+
   // Legacy-lock fallback firings on the beads write path. ~/.cx/beads-fallback.jsonl.
 
   'beads-fallback': {