@askexenow/exe-os 0.9.359 → 0.9.362

package/dist/chunk-QILQ5FCG.js

@@ -0,0 +1,198 @@
+import {
+  detectWSL,
+  probeContainer,
+  wslSystemdFixLines,
+  wslSystemdUnavailableDetail
+} from "./chunk-ARX6TAGN.js";
+
+// src/lib/linux-systemd.ts
+import { spawnSync } from "child_process";
+import { readFileSync } from "fs";
+function readPid1Comm() {
+  try {
+    return readFileSync("/proc/1/comm", "utf8").trim();
+  } catch {
+    return void 0;
+  }
+}
+var SYSTEMD_DAEMON_UNIT = "exe-os.service";
+var SYSTEMD_WATCHDOG_UNIT = "exe-os-watchdog.service";
+var SYSTEMD_USER_UNIT_DIR = [".config", "systemd", "user"];
+function assessSystemdUserEnv(input) {
+  const platform = input.platform ?? process.platform;
+  if (platform !== "linux") {
+    return { available: false, reason: "not-linux", wsl: false, detail: `systemd user units are Linux-only (platform: ${platform})` };
+  }
+  const env = input.env ?? process.env;
+  const wsl = input.isWsl ?? detectWSL({ platform, env });
+  const containerized = input.containerized ?? probeContainer();
+  const wslAdvice = wsl && !containerized;
+  if (!input.hasSystemctl) {
+    return {
+      available: false,
+      reason: "no-systemctl",
+      wsl,
+      detail: wslAdvice ? "systemctl not found in this WSL distro \u2014 WSL does not run systemd unless the distro opts in, so the daemon will run UNSUPERVISED (nothing restarts it if it crashes).\n" + wslSystemdFixLines().join("\n") + "\n  If systemctl is still missing afterwards, install it: sudo apt install -y systemd" : "systemctl not found \u2014 this host does not run systemd (Alpine/OpenRC, minimal container, WSL1). The daemon will run UNSUPERVISED: nothing restarts it if it crashes."
+    };
+  }
+  if (!env.XDG_RUNTIME_DIR && !env.DBUS_SESSION_BUS_ADDRESS) {
+    if (wslAdvice) {
+      return { available: false, reason: "wsl-no-systemd", wsl: true, detail: wslSystemdUnavailableDetail() };
+    }
+    return {
+      available: false,
+      reason: "no-user-bus",
+      wsl,
+      detail: 'no systemd user bus in this session (XDG_RUNTIME_DIR and DBUS_SESSION_BUS_ADDRESS are both unset) \u2014 `systemctl --user` will fail with "Failed to connect to bus". This is the normal state for a plain `ssh host <command>` or `su` session. Fix: log in with `ssh -t host` / `machinectl shell $USER@`, or run `sudo loginctl enable-linger $USER` and re-run the installer from a full login session.'
+    };
+  }
+  if (wslAdvice && input.pid1Comm !== void 0 && input.pid1Comm.trim() !== "systemd") {
+    return { available: false, reason: "wsl-no-systemd", wsl: true, detail: wslSystemdUnavailableDetail() };
+  }
+  return { available: true, reason: "ok", wsl, detail: "" };
+}
+function hasSystemctl(run = runCommand) {
+  return run("systemctl", ["--version"], 5e3).code === 0;
+}
+var runCommand = (cmd, args, timeoutMs) => {
+  try {
+    const r = spawnSync(cmd, args, { encoding: "utf8", timeout: timeoutMs });
+    return {
+      code: r.status,
+      stdout: (r.stdout ?? "").toString(),
+      stderr: (r.stderr ?? "").toString() + (r.error ? String(r.error.message) : "")
+    };
+  } catch (err) {
+    return { code: null, stdout: "", stderr: err instanceof Error ? err.message : String(err) };
+  }
+};
+function isActiveOutput(stdout) {
+  const s = stdout.trim();
+  return s === "active" || s === "activating" || s === "reloading";
+}
+function isUnitActive(unit, run = runCommand) {
+  return isActiveOutput(run("systemctl", ["--user", "is-active", unit], 5e3).stdout);
+}
+function isUnitEnabled(unit, run = runCommand) {
+  const r = run("systemctl", ["--user", "is-enabled", unit], 5e3);
+  const s = r.stdout.trim();
+  return r.code === 0 || s === "enabled" || s === "enabled-runtime" || s === "linked" || s === "static";
+}
+function buildDaemonUnit(opts) {
+  return `[Unit]
+Description=exe-os daemon
+After=network.target
+# The DEFAULT limit (5 starts / 10s) is too tight: a legitimate restart burst
+# would park the unit in "failed" and end supervision. Disabling the limiter
+# entirely (StartLimitIntervalSec=0) is the opposite mistake \u2014 the daemon's own
+# circuit breaker only covers crashes AFTER recordDaemonRestart(), so anything
+# earlier (module-load failure, corrupt dist, a libsql native-binding ABI
+# mismatch after a node upgrade) would loop at 6 restarts/minute forever while
+# "systemctl --user status" never says "failed". So: a GENEROUS bound. Normal
+# self-heal and update churn never reaches 20 starts in 5 minutes; a hard boot
+# failure does, and surfaces as a failed unit.
+# (StartLimit* belongs in [Unit] since systemd 230.)
+StartLimitIntervalSec=300
+StartLimitBurst=20
+
+[Service]
+Type=simple
+ExecStart=${opts.nodePath} --max-old-space-size=${opts.heapCapMB} --expose-gc ${opts.daemonPath}
+Restart=on-failure
+# RestartSec is LOAD-BEARING for the watchdog's successor-adoption logic: the
+# watchdog waits SUCCESSOR_WAIT_MS (15s, src/bin/exe-watchdog.ts) for systemd to
+# produce a replacement before it kickstarts one itself. That margin \u2014 15s wait
+# vs 10s restart delay \u2014 is the only thing preventing a double restart per
+# incident (the failure documented at length for launchd in exe-watchdog.ts).
+# Do not raise this above SUCCESSOR_WAIT_MS without raising that constant first.
+RestartSec=10
+Environment=HOME=${opts.home}
+Environment=PATH=${opts.pathEnv}
+WorkingDirectory=${opts.home}
+
+[Install]
+WantedBy=default.target
+`;
+}
+function buildWatchdogUnit(opts) {
+  return `[Unit]
+Description=exe-os daemon watchdog (health monitor)
+After=network.target
+# Bounded, not disabled: the watchdog has NO circuit breaker of its own, so an
+# unlimited Restart=always is an unbounded loop if the watchdog itself cannot
+# boot. 20 starts / 5 min is far above the self-update cadence (exit 0 when a
+# newer dist lands, a handful of times per day at most).
+StartLimitIntervalSec=300
+StartLimitBurst=20
+
+[Service]
+Type=simple
+ExecStart=${opts.nodePath} ${opts.watchdogPath}
+Restart=always
+RestartSec=10
+Environment=HOME=${opts.home}
+Environment=PATH=${opts.pathEnv}
+WorkingDirectory=${opts.home}
+
+[Install]
+WantedBy=default.target
+`;
+}
+function isUnitAbsentResult(r) {
+  if (r.code === 5) return true;
+  const text = `${r.stderr} ${r.stdout}`.toLowerCase();
+  return text.includes("not loaded") || text.includes("could not be found") || text.includes("no such file") || // No systemctl binary at all (Alpine/OpenRC, minimal container): there is no
+  // unit to stop, and treating that as a refusal would make `daemon stop`
+  // report failure on every systemd-less host.
+  text.includes("enoent");
+}
+function stopLinuxSupervisorUnits(run = runCommand) {
+  const order = [SYSTEMD_WATCHDOG_UNIT, SYSTEMD_DAEMON_UNIT];
+  const stopped = [];
+  const absent = [];
+  const failed = [];
+  for (const unit of order) {
+    const r = run("systemctl", ["--user", "stop", unit], 1e4);
+    if (r.code === 0) stopped.push(unit);
+    else if (isUnitAbsentResult(r)) absent.push(unit);
+    else failed.push({ unit, detail: (r.stderr || r.stdout).trim() || `exit ${String(r.code)}` });
+  }
+  const ok = failed.length === 0;
+  const detail = ok ? stopped.length ? `stopped ${stopped.join(" + ")}` : "no systemd units installed" : failed.map((f) => `${f.unit} refused to stop (${f.detail})`).join("; ");
+  return { ok, order, stopped, absent, failed, detail };
+}
+function startWatchdogUnit(run = runCommand) {
+  const r = run("systemctl", ["--user", "start", SYSTEMD_WATCHDOG_UNIT], 1e4);
+  if (r.code === 0) return { ok: true, detail: `${SYSTEMD_WATCHDOG_UNIT} started` };
+  if (isUnitAbsentResult(r)) return { ok: true, detail: `${SYSTEMD_WATCHDOG_UNIT} not installed \u2014 nothing to start` };
+  return { ok: false, detail: (r.stderr || r.stdout).trim() || `exit ${String(r.code)}` };
+}
+function enableLinger(user, run = runCommand) {
+  const already = run("loginctl", ["show-user", user, "--property=Linger"], 5e3);
+  if (already.stdout.trim() === "Linger=yes") return { ok: true, detail: "already enabled" };
+  const r = run("loginctl", ["enable-linger", user], 5e3);
+  if (r.code === 0) return { ok: true, detail: "enabled" };
+  return {
+    ok: false,
+    detail: `${(r.stderr || r.stdout).trim() || `exit ${String(r.code)}`} \u2014 the daemon will stop at logout. Fix: sudo loginctl enable-linger ${user}`
+  };
+}
+
+export {
+  readPid1Comm,
+  SYSTEMD_DAEMON_UNIT,
+  SYSTEMD_WATCHDOG_UNIT,
+  SYSTEMD_USER_UNIT_DIR,
+  assessSystemdUserEnv,
+  hasSystemctl,
+  runCommand,
+  isActiveOutput,
+  isUnitActive,
+  isUnitEnabled,
+  buildDaemonUnit,
+  buildWatchdogUnit,
+  isUnitAbsentResult,
+  stopLinuxSupervisorUnits,
+  startWatchdogUnit,
+  enableLinger
+};

package/dist/{chunk-LRETL4I3.js → chunk-QJBX3MBV.js}

@@ -1,16 +1,16 @@
 import {
   extractMemoryGraph
-} from "./chunk-2YGAKBRG.js";
+} from "./chunk-35FD67ZB.js";
 import {
   flushBatch,
   writeMemory
-} from "./chunk-W5YV2PZE.js";
+} from "./chunk-DKRDU2AX.js";
 import {
   extractKeywords
 } from "./chunk-CHCA3ZM2.js";
 import {
   getActiveAgent
-} from "./chunk-WRP5AG4D.js";
+} from "./chunk-23KWUA7Z.js";
 
 // src/mcp/tools/import-conversations.ts
 import { z } from "zod";

package/dist/{chunk-57GRYGDU.js → chunk-QP53XLC5.js}

@@ -2,7 +2,7 @@ import {
   getClient,
   isCoordinatorName,
   loadEmployeesSync
-} from "./chunk-EA5FVACM.js";
+} from "./chunk-HLU52KTO.js";
 
 // src/lib/steward-gate.ts
 import crypto from "crypto";

package/dist/{chunk-JBAMYKBL.js → chunk-QQMYD4M7.js}

@@ -1,6 +1,6 @@
 import {
   getClient
-} from "./chunk-EA5FVACM.js";
+} from "./chunk-HLU52KTO.js";
 
 // src/lib/boot-generation.ts
 var SYNC_META_KEY = "daemon_boot_generation";

package/dist/{chunk-SHEWTDPC.js → chunk-QY3TM2T3.js}

@@ -1,13 +1,13 @@
 import {
   deactivateBehavior
-} from "./chunk-6LY3QSJA.js";
+} from "./chunk-ZI3HA3XW.js";
 import {
   getActiveAgent
-} from "./chunk-WRP5AG4D.js";
+} from "./chunk-23KWUA7Z.js";
 import {
   canCoordinate,
   getClient
-} from "./chunk-EA5FVACM.js";
+} from "./chunk-HLU52KTO.js";
 
 // src/mcp/tools/deactivate-behavior.ts
 import { z } from "zod";
@@ -24,7 +24,7 @@ function registerDeactivateBehavior(server) {
     async ({ behavior_id }) => {
       const caller = getActiveAgent();
       try {
-        const { StewardGate } = await import("./steward-gate-CIOBPNX6.js");
+        const { StewardGate } = await import("./steward-gate-2ZNYDVFO.js");
         const steward = new StewardGate();
         const gateDecision = await steward.checkAuthority(caller.agentId || "unknown", "deactivate_behavior", behavior_id);
         if (!gateDecision.allowed) {

package/dist/{chunk-WA2MJGPT.js → chunk-QYRI25IP.js}

@@ -1,7 +1,7 @@
 import {
   getCurrentSessionScope,
   strictSessionScopeFilter
-} from "./chunk-74R44E4S.js";
+} from "./chunk-SQM4ZTL2.js";
 import {
   getProjectName
 } from "./chunk-OPU3NYOO.js";
@@ -53,9 +53,8 @@ async function ensureSessionEventsTable(client) {
 var DEFAULT_SESSION_EVENTS_RETENTION_DAYS = 14;
 async function sweepExpiredSessionEvents(client, retentionDays = DEFAULT_SESSION_EVENTS_RETENTION_DAYS) {
   const days = Number.isFinite(retentionDays) && retentionDays > 0 ? Math.floor(retentionDays) : DEFAULT_SESSION_EVENTS_RETENTION_DAYS;
-  await ensureSessionEventsTable(client);
   const cutoff = `-${days} days`;
-  const BATCH_SIZE = 5e3;
+  const BATCH_SIZE = 500;
   const MAX_BATCHES = 200;
   let total = 0;
   for (let i = 0; i < MAX_BATCHES; i++) {
@@ -72,6 +71,7 @@ async function sweepExpiredSessionEvents(client, retentionDays = DEFAULT_SESSION
     const affected = Number(result.rowsAffected ?? 0);
     total += affected;
     if (affected < BATCH_SIZE) break;
+    await new Promise((resolve) => setImmediate(resolve));
   }
   return total;
 }

package/dist/{chunk-QLFN3MUW.js → chunk-RCOIKTHM.js}

@@ -1,7 +1,7 @@
 import {
   loadConfig,
   saveConfig
-} from "./chunk-BCZF3AGJ.js";
+} from "./chunk-BRIZ6OZ3.js";
 
 // src/lib/orchestration-phase.ts
 var ORCHESTRATION_PHASES = [

package/dist/{chunk-ITRKRKS7.js → chunk-RFKRCVGW.js}

@@ -1,6 +1,6 @@
 import {
   EXE_AI_DIR
-} from "./chunk-BCZF3AGJ.js";
+} from "./chunk-BRIZ6OZ3.js";
 
 // src/lib/mcp-transport-health.ts
 import { appendFileSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, statSync, writeFileSync } from "fs";

package/dist/{chunk-HK7SQDKJ.js → chunk-RNSAVQEU.js}

@@ -7,10 +7,10 @@ import {
 } from "./chunk-Z6BZQHP5.js";
 import {
   WORK_STATE_HEARTBEAT_TOOL
-} from "./chunk-ZMYXQU4L.js";
+} from "./chunk-L4LPJMPV.js";
 import {
   hashMemoryContent
-} from "./chunk-FVWI2AR4.js";
+} from "./chunk-FIPUVCKC.js";
 
 // src/lib/graph-rag.ts
 import crypto from "crypto";

package/dist/{chunk-44WFVMZ5.js → chunk-RUUX2ZST.js}

@@ -1,7 +1,7 @@
 import {
   executeAction,
   substituteTemplate
-} from "./chunk-COHHVCFA.js";
+} from "./chunk-UELGUVNL.js";
 
 // src/automation/workflow-engine.ts
 import { randomUUID } from "crypto";

package/dist/{chunk-DWKH2H7W.js → chunk-RWKX2TK5.js}

@@ -1,6 +1,6 @@
 import {
   getClient
-} from "./chunk-EA5FVACM.js";
+} from "./chunk-HLU52KTO.js";
 
 // src/lib/token-budget.ts
 var WARN_THRESHOLD = 0.8;

package/dist/{chunk-MCNDZU5W.js → chunk-RYRNY6IF.js}

@@ -1,10 +1,10 @@
 import {
   embed
-} from "./chunk-I5AVZOL2.js";
+} from "./chunk-3YBJ36UX.js";
 import {
   flushBatch,
   writeMemory
-} from "./chunk-W5YV2PZE.js";
+} from "./chunk-DKRDU2AX.js";
 import {
   redactSecrets
 } from "./chunk-4QCFFW2H.js";

package/dist/{chunk-5I3YC7ER.js → chunk-SC6WDF3Q.js}

@@ -1,6 +1,6 @@
 import {
   sessionScopeFilter
-} from "./chunk-74R44E4S.js";
+} from "./chunk-SQM4ZTL2.js";
 
 // src/lib/git-task-sweep.ts
 import { execSync } from "child_process";
@@ -238,7 +238,7 @@ async function sweepTasks(projectName, options = {}) {
     }
     if (!dryRun) {
       try {
-        const { updateTaskStatus } = await import("./tasks-crud-IWVDREXG.js");
+        const { updateTaskStatus } = await import("./tasks-crud-NVNF3NRA.js");
         await updateTaskStatus({
           taskId: task.id,
           status: "needs_review",

package/dist/chunk-SLBOKYYQ.js

@@ -0,0 +1,197 @@
+import {
+  registerScopedQueryChokepoint,
+  scopedQueryChokepointStatus
+} from "./chunk-T2RZU7JA.js";
+import {
+  getClient
+} from "./chunk-HLU52KTO.js";
+
+// src/lib/org-scoped-rows.ts
+var SCOPED_QUERY_MAX_LIMIT = 200;
+var SCOPED_QUERY_DEFAULT_LIMIT = 50;
+var ScopedReadWindowError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ScopedReadWindowError";
+  }
+};
+function scopedQueryKey(orgId, q, structured) {
+  return JSON.stringify([
+    orgId,
+    structured ? "s" : "t",
+    [...q.kinds ?? []].sort(),
+    [...q.ids ?? []].sort(),
+    [...q.visibility ?? []].sort(),
+    q.tag ?? null,
+    normaliseLimit(q.limit)
+  ]);
+}
+function normaliseLimit(limit) {
+  if (typeof limit !== "number" || !Number.isFinite(limit) || limit <= 0) return SCOPED_QUERY_DEFAULT_LIMIT;
+  return Math.min(Math.floor(limit), SCOPED_QUERY_MAX_LIMIT);
+}
+var _window = null;
+function createDaemonScopedRowReader() {
+  const serve = (which, orgId, query) => {
+    const win = _window;
+    if (!win) {
+      throw new ScopedReadWindowError(
+        "A scoped row read was attempted outside a read window. Rows for a brief must be resolved by withScopedReadWindow() before the (synchronous) draft runs \u2014 there is no synchronous path to the database, and answering from stale state would mislabel provenance."
+      );
+    }
+    if (win.orgId !== orgId) {
+      throw new ScopedReadWindowError(
+        `A scoped row read for org "${orgId}" was attempted inside a read window opened for "${win.orgId}". Cross-org reads during drafting are excluded at the query layer (\xA71.5).`
+      );
+    }
+    const key = scopedQueryKey(orgId, query, which === "structured");
+    const rows = win[which].get(key);
+    if (!rows) {
+      throw new ScopedReadWindowError(
+        `No rows were prefetched for this ${which} query in the open read window. Declare every query in the plan passed to withScopedReadWindow(); an undeclared read cannot be answered and must not be answered with an empty result, which would look like a clean zero-source draft.`
+      );
+    }
+    return rows.map((r) => ({ ...r }));
+  };
+  return {
+    readTextRows: (orgId, query) => serve("text", orgId, query),
+    readStructuredRows: (orgId, query) => serve("structured", orgId, query)
+  };
+}
+function registerDaemonScopedQueryChokepoint(origin = "daemon") {
+  const before = scopedQueryChokepointStatus();
+  if (before.registered) {
+    if (before.origin === origin) return false;
+    throw new Error(
+      `Refusing to proceed: the scoped-query chokepoint was already registered by "${before.origin}", not by "${origin}". Whoever registers first defines what visibility means for this process, so a foreign registration is a correctness incident, not a warning.`
+    );
+  }
+  registerScopedQueryChokepoint(createDaemonScopedRowReader(), origin);
+  return true;
+}
+function str(v) {
+  return typeof v === "string" && v.length > 0 ? v : null;
+}
+function wantsKind(query, kind) {
+  return !query.kinds || query.kinds.length === 0 || query.kinds.includes(kind);
+}
+function visibilityFilter(query) {
+  const wanted = query.visibility?.filter((v) => typeof v === "string") ?? [];
+  if (wanted.length === 0) return { sql: "", args: [] };
+  return {
+    sql: ` AND COALESCE(visibility, 'private') IN (${wanted.map(() => "?").join(", ")})`,
+    args: [...wanted]
+  };
+}
+async function fetchMemoryRows(orgId, query) {
+  const client = getClient();
+  const limit = normaliseLimit(query.limit);
+  const vis = visibilityFilter(query);
+  const args = [];
+  let sql = "SELECT id, content, category, visibility, origin_org_id FROM memories WHERE (deleted_at IS NULL OR deleted_at = '')";
+  if (query.ids?.length) {
+    sql += ` AND id IN (${query.ids.map(() => "?").join(", ")})`;
+    args.push(...query.ids);
+  }
+  sql += vis.sql;
+  args.push(...vis.args);
+  sql += " AND (COALESCE(visibility, 'private') = 'private' OR origin_org_id IS NULL OR origin_org_id = ?)";
+  args.push(orgId);
+  if (query.tag) {
+    sql += " AND (category = ? OR content LIKE ?)";
+    args.push(query.tag, `%${query.tag}%`);
+  }
+  sql += " ORDER BY created_at DESC LIMIT ?";
+  args.push(limit);
+  const res = await client.execute({ sql, args });
+  return res.rows.map((r) => ({
+    id: String(r.id),
+    kind: "memory",
+    visibility: str(r.visibility),
+    origin_org_id: str(r.origin_org_id),
+    label: str(r.category),
+    text: typeof r.content === "string" ? r.content : ""
+  }));
+}
+async function fetchTaskRows(orgId, query) {
+  const client = getClient();
+  const limit = normaliseLimit(query.limit);
+  const vis = visibilityFilter(query);
+  const args = [];
+  let sql = "SELECT id, title, description, result, status, visibility, origin_org_id FROM tasks WHERE 1=1";
+  if (query.ids?.length) {
+    sql += ` AND id IN (${query.ids.map(() => "?").join(", ")})`;
+    args.push(...query.ids);
+  }
+  sql += vis.sql;
+  args.push(...vis.args);
+  sql += " AND (COALESCE(visibility, 'private') = 'private' OR origin_org_id IS NULL OR origin_org_id = ?)";
+  args.push(orgId);
+  if (query.tag) {
+    sql += " AND status = ?";
+    args.push(query.tag);
+  }
+  sql += " ORDER BY created_at DESC LIMIT ?";
+  args.push(limit);
+  const res = await client.execute({ sql, args });
+  return res.rows.map((r) => {
+    const structured = {
+      task_id: String(r.id),
+      summary: (str(r.result) ?? str(r.description) ?? str(r.title) ?? "").slice(0, 2e3),
+      files_changed: [],
+      decisions: [],
+      open_questions: [],
+      commits: [],
+      tests: "none",
+      build: "skip"
+    };
+    return {
+      id: String(r.id),
+      kind: "task",
+      visibility: str(r.visibility),
+      origin_org_id: str(r.origin_org_id),
+      label: str(r.title),
+      text: `${str(r.title) ?? ""}${r.result ? `: ${String(r.result)}` : ""}`,
+      structured
+    };
+  });
+}
+async function resolveQuery(orgId, query, structured) {
+  const out = [];
+  if (!structured && wantsKind(query, "memory")) out.push(...await fetchMemoryRows(orgId, query));
+  if (wantsKind(query, "task")) out.push(...await fetchTaskRows(orgId, query));
+  return out;
+}
+async function withScopedReadWindow(orgId, plan, fn) {
+  if (!orgId) throw new Error("A scoped read window requires a non-empty org_id (\xA71.5)");
+  if (_window) {
+    throw new ScopedReadWindowError(
+      `A scoped read window is already open for "${_window.orgId}". Windows do not nest: the no-interleaving property that makes a synchronous reader safe depends on exactly one being open.`
+    );
+  }
+  const text = /* @__PURE__ */ new Map();
+  const structured = /* @__PURE__ */ new Map();
+  for (const q of plan.text ?? []) {
+    text.set(scopedQueryKey(orgId, q, false), await resolveQuery(orgId, q, false));
+  }
+  for (const q of plan.structured ?? []) {
+    structured.set(scopedQueryKey(orgId, q, true), await resolveQuery(orgId, q, true));
+  }
+  _window = { orgId, text, structured };
+  try {
+    const result = fn();
+    if (result && typeof result.then === "function") {
+      throw new ScopedReadWindowError(
+        "withScopedReadWindow() was handed an async function. The window closes when the call returns, so an async body would read rows after the window it declared had gone."
+      );
+    }
+    return result;
+  } finally {
+    _window = null;
+  }
+}
+
+export {
+  registerDaemonScopedQueryChokepoint,
+  withScopedReadWindow
+};