@rubytech/create-realagent 1.0.837 → 1.0.839

package/payload/server/neo4j-migrations-4PG2KB4W.js

@@ -0,0 +1,665 @@
+import {
+  ACCOUNTS_DIR
+} from "./chunk-OJZPS4BL.js";
+import {
+  getSession,
+  projectAgent
+} from "./chunk-7PLAT6UR.js";
+import "./chunk-JSBRDJBE.js";
+
+// app/lib/neo4j-migrations.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve4 } from "path";
+
+// ../neo4j/migrations/004-prune-alien-accounts.ts
+import { readFileSync, readdirSync } from "fs";
+import { resolve } from "path";
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+async function pruneAlienAccounts(driver, platformRoot) {
+  const accountsDir = resolve(platformRoot, "..", "data", "accounts");
+  const validIds = enumerateValidAccountIds(accountsDir);
+  if (validIds.size === 0) {
+    throw new Error(
+      `refusing to prune: no valid accounts found under ${accountsDir} \u2014 corrupt install? not deleting anything to avoid wiping the entire graph.`
+    );
+  }
+  const valid = Array.from(validIds);
+  const session = driver.session();
+  try {
+    const peek = await session.run(
+      `MATCH (n)
+       WHERE n.accountId IS NOT NULL AND NOT n.accountId IN $valid
+       RETURN DISTINCT n.accountId AS aid`,
+      { valid }
+    );
+    const alienIds = [];
+    for (const record of peek.records) {
+      const aid = record.get("aid");
+      if (typeof aid === "string") alienIds.push(aid);
+    }
+    if (alienIds.length === 0) return;
+    const result = await session.run(
+      `MATCH (n)
+       WHERE n.accountId IS NOT NULL AND NOT n.accountId IN $valid
+       DETACH DELETE n
+       RETURN count(n) AS pruned`,
+      { valid }
+    );
+    const prunedRaw = result.records[0]?.get("pruned");
+    const pruned = typeof prunedRaw === "number" ? prunedRaw : prunedRaw?.toNumber?.() ?? 0;
+    console.error(
+      `[graph-invariant] alien-accounts pruned=${pruned} accountIds=${alienIds.join(",")}`
+    );
+  } finally {
+    await session.close();
+  }
+}
+function enumerateValidAccountIds(accountsDir) {
+  const valid = /* @__PURE__ */ new Set();
+  let names;
+  try {
+    names = readdirSync(accountsDir);
+  } catch (err) {
+    if (err.code === "ENOENT") return valid;
+    throw err;
+  }
+  for (const name of names) {
+    if (!UUID_RE.test(name)) continue;
+    const configPath = resolve(accountsDir, name, "account.json");
+    try {
+      JSON.parse(readFileSync(configPath, "utf-8"));
+      valid.add(name);
+    } catch (err) {
+      const code = err.code ?? "parse-error";
+      if (code === "ENOENT") continue;
+      console.error(
+        `[graph-invariant] account-json-skip uuid=${name} reason=${code}`
+      );
+    }
+  }
+  return valid;
+}
+
+// ../neo4j/migrations/004-project-admin-agent.ts
+import { existsSync, readFileSync as readFileSync2, readdirSync as readdirSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+function readValidAccountDirs(accountsDir) {
+  const valid = [];
+  const entries = readdirSync2(accountsDir, { withFileTypes: true }).filter((e) => e.isDirectory()).filter((e) => !e.name.startsWith("."));
+  for (const e of entries) {
+    const configPath = resolve2(accountsDir, e.name, "account.json");
+    if (!existsSync(configPath)) {
+      console.error(
+        `[platform] accounts-state STUB-DIR id=${e.name} \u2014 onboarding leak; remove or repair`
+      );
+      continue;
+    }
+    try {
+      JSON.parse(readFileSync2(configPath, "utf-8"));
+      valid.push(e.name);
+    } catch {
+      console.error(
+        `[platform] accounts-state CORRUPT-JSON id=${e.name} \u2014 account.json failed to parse`
+      );
+    }
+  }
+  return valid;
+}
+async function projectAccountAdmin(accountId, accountDir) {
+  const adminDir = resolve2(accountDir, "agents", "admin");
+  const configPath = resolve2(adminDir, "config.json");
+  if (!existsSync(adminDir) || !existsSync(configPath)) {
+    return { projected: 0, failed: 0 };
+  }
+  try {
+    await projectAgent(accountId, accountDir, "admin");
+    return { projected: 1, failed: 0 };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(
+      `[admin-agent-graph-backfill] account=${accountId.slice(0, 8)} project FAILED error="${msg}"`
+    );
+    return { projected: 0, failed: 1 };
+  }
+}
+async function backfillAdminHandledBy(driver, accountId) {
+  const session = driver.session();
+  try {
+    const result = await session.run(
+      `MATCH (c:AdminConversation {accountId: $accountId})
+       WHERE NOT EXISTS((c)-[:HANDLED_BY]->(:Agent))
+       OPTIONAL MATCH (a:Agent {accountId: $accountId, slug: 'admin'})
+       FOREACH (_ IN CASE WHEN a IS NULL THEN [] ELSE [1] END | MERGE (c)-[:HANDLED_BY]->(a))
+       RETURN
+         count(c) AS candidates,
+         sum(CASE WHEN a IS NULL THEN 0 ELSE 1 END) AS edges`,
+      { accountId }
+    );
+    const toNum = (v) => {
+      if (typeof v === "number") return v;
+      if (v && typeof v.toNumber === "function") {
+        return v.toNumber();
+      }
+      return 0;
+    };
+    return {
+      candidates: toNum(result.records[0]?.get("candidates")),
+      edges: toNum(result.records[0]?.get("edges"))
+    };
+  } finally {
+    await session.close();
+  }
+}
+async function backfillChannel(driver, accountId) {
+  const session = driver.session();
+  try {
+    const result = await session.run(
+      `MATCH (c:Conversation {accountId: $accountId})
+       WHERE c.channel IS NULL
+       SET c.channel = 'webchat'
+       RETURN count(c) AS backfilled`,
+      { accountId }
+    );
+    const raw = result.records[0]?.get("backfilled");
+    if (typeof raw === "number") return raw;
+    if (raw && typeof raw.toNumber === "function") {
+      return raw.toNumber();
+    }
+    return 0;
+  } finally {
+    await session.close();
+  }
+}
+async function applyAdminAgentBackfill(driver, platformRoot) {
+  const accountsDir = resolve2(platformRoot, "..", "data", "accounts");
+  const start = Date.now();
+  if (!existsSync(accountsDir)) {
+    console.error(
+      `[admin-agent-graph-backfill] accounts-dir missing at ${accountsDir} \u2014 nothing to do`
+    );
+    return;
+  }
+  const accountEntries = readValidAccountDirs(accountsDir).map((name) => ({ name }));
+  console.error(
+    `[admin-agent-graph-backfill] start accounts=${accountEntries.length}`
+  );
+  let totalProjected = 0;
+  let totalFailed = 0;
+  let totalHandledByCandidates = 0;
+  let totalHandledByEdges = 0;
+  let totalChannelBackfilled = 0;
+  const perAccount = [];
+  for (const entry of accountEntries) {
+    const accountDir = resolve2(accountsDir, entry.name);
+    const accountId = entry.name;
+    const accountStart = Date.now();
+    const { projected, failed } = await projectAccountAdmin(
+      accountId,
+      accountDir
+    );
+    totalProjected += projected;
+    totalFailed += failed;
+    let handledByStats = { candidates: 0, edges: 0 };
+    let channelBackfilled = 0;
+    try {
+      handledByStats = await backfillAdminHandledBy(driver, accountId);
+      totalHandledByCandidates += handledByStats.candidates;
+      totalHandledByEdges += handledByStats.edges;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(
+        `[admin-agent-graph-backfill] account=${accountId.slice(0, 8)} handled-by-backfill FAILED error="${msg}"`
+      );
+    }
+    try {
+      channelBackfilled = await backfillChannel(driver, accountId);
+      totalChannelBackfilled += channelBackfilled;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(
+        `[admin-agent-graph-backfill] account=${accountId.slice(0, 8)} channel-backfill FAILED error="${msg}"`
+      );
+    }
+    perAccount.push({
+      accountId,
+      projected,
+      failed,
+      handledByCandidates: handledByStats.candidates,
+      handledByEdges: handledByStats.edges,
+      channelBackfilled
+    });
+    const ms2 = Date.now() - accountStart;
+    console.error(
+      `[admin-agent-graph-backfill] account=${accountId.slice(0, 8)} projected=${projected} failed=${failed} handled-by-candidates=${handledByStats.candidates} handled-by-edges=${handledByStats.edges} channel-backfilled=${channelBackfilled} ms=${ms2}`
+    );
+  }
+  const ms = Date.now() - start;
+  console.error(
+    `[admin-agent-graph-backfill] done totals: projected=${totalProjected} failed=${totalFailed} handled-by-candidates=${totalHandledByCandidates} handled-by-edges=${totalHandledByEdges} channel-backfilled=${totalChannelBackfilled} ms=${ms}`
+  );
+}
+async function main() {
+  if (!existsSync(ACCOUNTS_DIR)) {
+    console.error(
+      `[admin-agent-graph-backfill] ACCOUNTS_DIR missing at ${ACCOUNTS_DIR} \u2014 nothing to do`
+    );
+    process.exit(0);
+  }
+  const driverShim = { session: () => getSession() };
+  const platformRoot = resolve2(ACCOUNTS_DIR, "..", "..", "platform");
+  try {
+    await applyAdminAgentBackfill(driverShim, platformRoot);
+    process.exit(0);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[admin-agent-graph-backfill] fatal error="${msg}"`);
+    process.exit(2);
+  }
+}
+if (process.argv[1]?.endsWith("004-project-admin-agent.ts")) {
+  main().catch((err) => {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[admin-agent-graph-backfill] fatal error="${msg}"`);
+    process.exit(2);
+  });
+}
+
+// ../neo4j/migrations/005-removed-review-feature.ts
+import { resolve as resolve3 } from "path";
+import { unlinkSync } from "fs";
+import { homedir } from "os";
+import { basename, dirname } from "path";
+async function removeReviewFeature(driver, platformRoot) {
+  const session = driver.session();
+  let eventsDeleted = 0;
+  let alertsDeleted = 0;
+  try {
+    const eventResult = await session.run(
+      `MATCH (e:Event)
+       WHERE e.actionTool = "review-digest-compose"
+          OR e.eventId STARTS WITH "review-digest-"
+       DETACH DELETE e
+       RETURN count(e) AS deleted`
+    );
+    eventsDeleted = toNumber(eventResult.records[0]?.get("deleted"));
+    const alertResult = await session.run(
+      `MATCH (a:ReviewAlert)
+       DETACH DELETE a
+       RETURN count(a) AS deleted`
+    );
+    alertsDeleted = toNumber(alertResult.records[0]?.get("deleted"));
+  } finally {
+    await session.close();
+  }
+  const installDirName = basename(dirname(platformRoot));
+  const configDir = resolve3(homedir(), `.${installDirName}`);
+  const artefacts = [
+    resolve3(configDir, "logs", "review.log"),
+    resolve3(configDir, "review-rules.json"),
+    resolve3(configDir, "review-state.json"),
+    resolve3(configDir, "review-pending-alerts.jsonl")
+  ];
+  for (const path of artefacts) {
+    try {
+      unlinkSync(path);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT") continue;
+      console.error(
+        `[migration] removed-review-feature unlink-skip path=${path} reason=${code ?? "unknown"}`
+      );
+    }
+  }
+  console.error(
+    `[migration] removed-review-feature events=${eventsDeleted} alerts=${alertsDeleted}`
+  );
+}
+function toNumber(v) {
+  if (typeof v === "number") return v;
+  if (v && typeof v.toNumber === "function") {
+    return v.toNumber();
+  }
+  return 0;
+}
+
+// ../neo4j/migrations/006-prune-bogus-whatsapp-persons.ts
+var POLLUTED_NAME_REGEX = "(?s).*[\\n\\[].*";
+async function pruneBogusWhatsappPersons(driver) {
+  const session = driver.session();
+  try {
+    const nonAutoRes = await session.run(
+      `MATCH (p:Person {source: 'whatsapp'})
+       WHERE coalesce(p.participantStatus, '') <> 'auto-created'
+         AND p.name =~ $regex
+       RETURN elementId(p) AS elementId, p.name AS name`,
+      { regex: POLLUTED_NAME_REGEX }
+    );
+    const skippedNonAuto = nonAutoRes.records.length;
+    for (const record of nonAutoRes.records) {
+      const elementId = record.get("elementId");
+      const name = record.get("name");
+      console.error(
+        `[migration:whatsapp-bogus-person-prune] non-auto-match elementId=${elementId} name=${JSON.stringify(name)}`
+      );
+    }
+    const matchedRes = await session.run(
+      `MATCH (p:Person {source: 'whatsapp', participantStatus: 'auto-created'})
+       WHERE p.name =~ $regex
+       RETURN count(p) AS matched`,
+      { regex: POLLUTED_NAME_REGEX }
+    );
+    const matched = toNumber2(matchedRes.records[0]?.get("matched"));
+    if (matched === 0) {
+      console.error(
+        `[migration:whatsapp-bogus-person-prune] matched=0 deleted=0 skipped-non-auto=${skippedNonAuto}`
+      );
+      return;
+    }
+    const deleteRes = await session.run(
+      `MATCH (p:Person {source: 'whatsapp', participantStatus: 'auto-created'})
+       WHERE p.name =~ $regex
+       DETACH DELETE p
+       RETURN count(p) AS deleted`,
+      { regex: POLLUTED_NAME_REGEX }
+    );
+    const deleted = toNumber2(deleteRes.records[0]?.get("deleted"));
+    console.error(
+      `[migration:whatsapp-bogus-person-prune] matched=${matched} deleted=${deleted} skipped-non-auto=${skippedNonAuto}`
+    );
+  } finally {
+    await session.close();
+  }
+}
+function toNumber2(v) {
+  if (typeof v === "number") return v;
+  if (v && typeof v.toNumber === "function") {
+    return v.toNumber();
+  }
+  return 0;
+}
+
+// ../neo4j/migrations/007-conversation-archive-source.ts
+async function backfillConversationArchiveSource(driver) {
+  const session = driver.session();
+  try {
+    const archivesSourceSet = await runCount(
+      session,
+      `MATCH (a:ConversationArchive)
+       WHERE a.source IS NULL
+       SET a.source = 'whatsapp'
+       RETURN count(a) AS n`
+    );
+    const archivesAgentRenamed = await runCount(
+      session,
+      `MATCH (a:ConversationArchive)
+       WHERE a.createdByAgent = 'whatsapp-import'
+       SET a.createdByAgent = 'conversation-archive'
+       RETURN count(a) AS n`
+    );
+    const chunksSourceSet = await runCount(
+      session,
+      `MATCH (c:Section:Conversation)
+       WHERE c.source IS NULL
+       SET c.source = 'whatsapp'
+       RETURN count(c) AS n`
+    );
+    const chunksAgentRenamed = await runCount(
+      session,
+      `MATCH (c:Section:Conversation)
+       WHERE c.createdByAgent = 'whatsapp-import'
+       SET c.createdByAgent = 'conversation-archive'
+       RETURN count(c) AS n`
+    );
+    const edgesAgentRenamed = await runCount(
+      session,
+      `MATCH (a:ConversationArchive)-[r]-()
+       WHERE r.createdByAgent = 'whatsapp-import'
+       SET r.createdByAgent = 'conversation-archive'
+       RETURN count(r) AS n`
+    );
+    console.error(
+      `[migration:conversation-archive-source] archives-source-set=${archivesSourceSet} archives-agent-renamed=${archivesAgentRenamed} chunks-source-set=${chunksSourceSet} chunks-agent-renamed=${chunksAgentRenamed} edges-agent-renamed=${edgesAgentRenamed}`
+    );
+  } finally {
+    await session.close();
+  }
+}
+async function runCount(session, cypher) {
+  const res = await session.run(cypher);
+  const v = res.records[0]?.get("n");
+  if (typeof v === "number") return v;
+  if (v && typeof v.toNumber === "function") {
+    return v.toNumber();
+  }
+  return 0;
+}
+
+// ../neo4j/migrations/008-adminuser-accountid-backfill.ts
+async function backfillAdminUserAccountId(driver) {
+  const session = driver.session();
+  try {
+    const backfilled = await runCount2(
+      session,
+      `MATCH (au:AdminUser) WHERE au.accountId IS NULL
+       OPTIONAL MATCH (au)-[:ADMIN_OF]->(b:LocalBusiness)
+       WITH au, b WHERE b IS NOT NULL AND b.accountId IS NOT NULL
+       SET au.accountId = b.accountId
+       RETURN count(au) AS n`
+    );
+    const residualNull = await runCount2(
+      session,
+      `MATCH (au:AdminUser) WHERE au.accountId IS NULL
+       RETURN count(au) AS n`
+    );
+    console.error(
+      `[migration:adminuser-accountid] backfilled=${backfilled} residual-null=${residualNull}`
+    );
+    if (residualNull > 0) {
+      throw new Error(
+        `migration:adminuser-accountid: ${residualNull} :AdminUser node(s) still carry a null accountId after backfill \u2014 no ADMIN_OF edge to derive from. Manual reconciliation required (cypher-shell into the graph; either DELETE the orphan or attach a valid ADMIN_OF edge and re-run boot).`
+      );
+    }
+  } finally {
+    await session.close();
+  }
+}
+async function runCount2(session, cypher) {
+  const res = await session.run(cypher);
+  const v = res.records[0]?.get("n");
+  if (typeof v === "number") return v;
+  if (v && typeof v.toNumber === "function") {
+    return v.toNumber();
+  }
+  return 0;
+}
+
+// ../neo4j/migrations/009-conversation-archive-title.ts
+var ISO_DATE_RE = /^(\d{4}-\d{2}-\d{2})/;
+function isoToYmd(iso) {
+  if (typeof iso !== "string") return "?";
+  const m = iso.match(ISO_DATE_RE);
+  return m ? m[1] : "?";
+}
+function pickName(row) {
+  if (row.labels.includes("AdminUser")) {
+    if (row.displayName && row.displayName.trim()) return row.displayName.trim();
+    if (row.slug && row.slug.trim()) return row.slug.trim();
+  }
+  if (row.labels.includes("Person")) {
+    const full = [row.givenName, row.familyName].filter((s) => typeof s === "string" && s.trim().length > 0).map((s) => s.trim()).join(" ");
+    if (full) return full;
+  }
+  return row.elementId.slice(0, 8);
+}
+function asString(v) {
+  return typeof v === "string" ? v : void 0;
+}
+async function backfillConversationArchiveTitle(driver) {
+  const session = driver.session();
+  let archivesTitled = 0;
+  let degradedNoDates = 0;
+  let degradedNoNames = 0;
+  try {
+    const archives = await session.run(
+      `MATCH (a:ConversationArchive)
+       WHERE a.title IS NULL
+       RETURN elementId(a) AS elemId,
+              coalesce(a.source, 'whatsapp') AS source,
+              a.lastIngestedMessageAt AS lastAt`
+    );
+    for (const rec of archives.records) {
+      const elemId = rec.get("elemId");
+      const source = rec.get("source");
+      const fallbackLastAt = rec.get("lastAt");
+      const partRes = await session.run(
+        `MATCH (p)-[:PARTICIPANT_IN]->(a:ConversationArchive)
+         WHERE elementId(a) = $elemId AND (p:Person OR p:AdminUser)
+         RETURN elementId(p) AS elemId, labels(p) AS labels, properties(p) AS props`,
+        { elemId }
+      );
+      const owner = [];
+      const others = [];
+      let anyDegraded = false;
+      for (const r of partRes.records) {
+        const labels = r.get("labels") || [];
+        const props = r.get("props") || {};
+        const row = {
+          elementId: r.get("elemId"),
+          labels,
+          displayName: asString(props.displayName),
+          slug: asString(props.slug),
+          givenName: asString(props.givenName),
+          familyName: asString(props.familyName)
+        };
+        const name = pickName(row);
+        if (name === row.elementId.slice(0, 8)) anyDegraded = true;
+        if (labels.includes("AdminUser")) owner.push(row);
+        else others.push(row);
+      }
+      if (anyDegraded) degradedNoNames += 1;
+      const ownerName = owner.length > 0 ? pickName(owner[0]) : "?";
+      const otherNames = others.length > 0 ? others.map((o) => pickName(o)).join(", ") : "?";
+      const datesRes = await session.run(
+        `MATCH (a:ConversationArchive)-[:HAS_SECTION]->(c:Section:Conversation)
+         WHERE elementId(a) = $elemId
+         WITH c, c.firstMessageAt AS first, c.lastMessageAt AS last
+         RETURN min(first) AS firstAt, max(last) AS lastAt`,
+        { elemId }
+      );
+      let firstAt = asString(datesRes.records[0]?.get("firstAt"));
+      let lastAt = asString(datesRes.records[0]?.get("lastAt"));
+      if (!firstAt || !lastAt) {
+        if (fallbackLastAt) {
+          firstAt = firstAt ?? fallbackLastAt;
+          lastAt = lastAt ?? fallbackLastAt;
+        }
+      }
+      if (!firstAt || !lastAt) {
+        degradedNoDates += 1;
+      }
+      const firstYmd = isoToYmd(firstAt);
+      const lastYmd = isoToYmd(lastAt);
+      const title = `${source} \xB7 ${ownerName} \u2194 ${otherNames} \xB7 ${firstYmd}\u2192${lastYmd}`;
+      const upd = await session.run(
+        `MATCH (a:ConversationArchive)
+         WHERE elementId(a) = $elemId AND a.title IS NULL
+         SET a.title = $title
+         RETURN count(a) AS n`,
+        { elemId, title }
+      );
+      const n = upd.records[0]?.get("n");
+      const v = typeof n === "number" ? n : n?.toNumber?.() ?? 0;
+      if (v > 0) archivesTitled += 1;
+    }
+    console.error(
+      `[migration:conversation-archive-title] archives-titled=${archivesTitled} degraded-no-dates=${degradedNoDates} degraded-no-names=${degradedNoNames}`
+    );
+  } finally {
+    await session.close();
+  }
+}
+
+// app/lib/neo4j-migrations.ts
+var BOOT_MIGRATIONS = [
+  { fileName: "003-person-name-eradicate.cypher", slug: "person-name-eradicate" }
+];
+async function applyBootMigrations(driver, platformRoot) {
+  for (const migration of BOOT_MIGRATIONS) {
+    await applyOne(driver, platformRoot, migration);
+  }
+  try {
+    await pruneAlienAccounts(driver, platformRoot);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[migration] failed prune-alien-accounts error="${msg}"`);
+  }
+  try {
+    await applyAdminAgentBackfill(driver, platformRoot);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[migration] failed admin-agent-graph-backfill error="${msg}"`);
+  }
+  try {
+    await removeReviewFeature(driver, platformRoot);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[migration] failed removed-review-feature error="${msg}"`);
+  }
+  try {
+    await pruneBogusWhatsappPersons(driver);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[migration] failed prune-bogus-whatsapp-persons error="${msg}"`);
+  }
+  try {
+    await backfillConversationArchiveSource(driver);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[migration] failed conversation-archive-source error="${msg}"`);
+  }
+  await backfillAdminUserAccountId(driver);
+  try {
+    await backfillConversationArchiveTitle(driver);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[migration] failed conversation-archive-title error="${msg}"`);
+  }
+}
+async function applyOne(driver, platformRoot, migration) {
+  const path = resolve4(platformRoot, "neo4j/migrations", migration.fileName);
+  let cypher;
+  try {
+    cypher = readFileSync3(path, "utf-8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(
+      `[migration] failed ${migration.slug} error=cannot-read-file path=${path} msg=${msg}`
+    );
+    return;
+  }
+  const session = driver.session();
+  try {
+    const result = await session.run(cypher);
+    const record = result.records[0];
+    const removedRaw = record?.get("removed");
+    const removed = toNumber3(removedRaw);
+    console.error(
+      `[migration] applied ${migration.slug} removed=${removed}`
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[migration] failed ${migration.slug} error="${msg}"`);
+  } finally {
+    await session.close();
+  }
+}
+function toNumber3(v) {
+  if (typeof v === "number") return v;
+  if (v && typeof v.toNumber === "function") {
+    return v.toNumber();
+  }
+  return 0;
+}
+export {
+  applyBootMigrations
+};