@promptowl/contextnest-community 1.8.0 → 1.10.0

package/dist/chunk-ZM4F7MY7.js

@@ -0,0 +1,1343 @@
+import {
+  grantCoversNode,
+  listUserGrants,
+  resolveNodeGrant
+} from "./chunk-7PQREKSM.js";
+import {
+  createVersion,
+  getApprovedVersion,
+  setApprovedVersion
+} from "./chunk-UHUU3VAK.js";
+import {
+  buildDocContext,
+  buildTitleMap,
+  canUserAccess,
+  canUserApprove,
+  describeNode,
+  engineCache,
+  isPublicReader,
+  isStewardshipEnabled,
+  resolveStewardsForNode
+} from "./chunk-KFGZIECB.js";
+import {
+  ConflictError,
+  NotFoundError,
+  ValidationError
+} from "./chunk-3JTODC3Y.js";
+import {
+  insertOrReplace,
+  nowExpr
+} from "./chunk-XQ46F76G.js";
+import {
+  config,
+  getDb
+} from "./chunk-BC6KFUZH.js";
+
+// src/governance/review-service.ts
+import { v4 as uuid3 } from "uuid";
+
+// src/governance/notify-service.ts
+import { v4 as uuid } from "uuid";
+async function listWatchers(nestId, nodeId) {
+  return await getDb().all(
+    `SELECT id, node_id, user_email, created_by, created_at
+       FROM watchers WHERE nest_id = ? AND node_id = ? ORDER BY created_at`,
+    [nestId, nodeId]
+  );
+}
+async function addWatcher(nestId, nodeId, userEmail, createdBy) {
+  await getDb().run(
+    `INSERT INTO watchers (id, nest_id, node_id, user_email, created_by, created_at)
+     VALUES (?, ?, ?, ?, ?, ?)
+     ON CONFLICT(nest_id, node_id, user_email) DO NOTHING`,
+    [uuid(), nestId, nodeId, userEmail.toLowerCase(), createdBy, (/* @__PURE__ */ new Date()).toISOString()]
+  );
+}
+async function removeWatcher(nestId, nodeId, userEmail) {
+  const db = getDb();
+  const row = await db.get(
+    "SELECT id FROM watchers WHERE nest_id = ? AND node_id = ? AND LOWER(user_email) = LOWER(?)",
+    [nestId, nodeId, userEmail]
+  );
+  if (!row) return false;
+  await db.run("DELETE FROM watchers WHERE id = ?", [row.id]);
+  return true;
+}
+async function notifyReviewRequested(params) {
+  const { nestId, nodeId, requestedBy, reviewId } = params;
+  const db = getDb();
+  try {
+    const rows = await db.all(
+      `SELECT DISTINCT w.user_email, w.node_id AS via
+         FROM watchers w
+        WHERE w.nest_id = ?
+          AND (w.node_id = ?
+               OR w.node_id IN (
+                 SELECT e.from_node FROM edges e
+                   JOIN edge_types t ON t.id = e.type_id
+                  WHERE e.nest_id = ? AND e.to_node = ? AND t.is_flow = 1
+               ))`,
+      [nestId, nodeId, nestId, nodeId]
+    );
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    let created = 0;
+    for (const r of rows) {
+      if (r.user_email.toLowerCase() === requestedBy.toLowerCase()) continue;
+      await db.run(
+        `INSERT INTO notifications (id, nest_id, user_email, kind, subject_id, message, created_at)
+         VALUES (?, ?, ?, 'review_requested', ?, ?, ?)`,
+        [
+          uuid(),
+          nestId,
+          r.user_email.toLowerCase(),
+          reviewId,
+          r.via === nodeId ? `"${nodeId}" has a new version awaiting review (submitted by ${requestedBy})` : `Agent "${r.via}" produced output on "${nodeId}" \u2014 awaiting review`,
+          now
+        ]
+      );
+      created++;
+    }
+    return created;
+  } catch (err) {
+    console.error("[notify] review fan-out failed", nestId, nodeId, err);
+    return 0;
+  }
+}
+async function notifyReviewResolved(params) {
+  const { nestId, nodeId, status, resolvedBy, requestedBy, reviewId } = params;
+  const db = getDb();
+  try {
+    const rows = await db.all(
+      `SELECT DISTINCT w.user_email
+         FROM watchers w
+        WHERE w.nest_id = ?
+          AND (w.node_id = ?
+               OR w.node_id IN (
+                 SELECT e.from_node FROM edges e
+                   JOIN edge_types t ON t.id = e.type_id
+                  WHERE e.nest_id = ? AND e.to_node = ? AND t.is_flow = 1
+               ))`,
+      [nestId, nodeId, nestId, nodeId]
+    );
+    const recipients = new Set(rows.map((r) => r.user_email.toLowerCase()));
+    recipients.add(requestedBy.toLowerCase());
+    recipients.delete(resolvedBy.toLowerCase());
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    let created = 0;
+    for (const email of recipients) {
+      await db.run(
+        `INSERT INTO notifications (id, nest_id, user_email, kind, subject_id, message, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`,
+        [
+          uuid(),
+          nestId,
+          email,
+          `review_${status}`,
+          reviewId,
+          `"${nodeId}" was ${status} by ${resolvedBy}`,
+          now
+        ]
+      );
+      created++;
+    }
+    return created;
+  } catch (err) {
+    console.error("[notify] resolution fan-out failed", nestId, nodeId, err);
+    return 0;
+  }
+}
+async function listNotifications(userEmail, opts = {}) {
+  const limit = Math.min(opts.limit ?? 50, 200);
+  return await getDb().all(
+    `SELECT id, nest_id, kind, subject_id, message, created_at, read_at
+       FROM notifications
+      WHERE LOWER(user_email) = LOWER(?)${opts.unreadOnly ? " AND read_at IS NULL" : ""}
+      ORDER BY created_at DESC LIMIT ${limit}`,
+    [userEmail]
+  );
+}
+async function markNotificationsRead(userEmail, ids) {
+  const db = getDb();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (ids === "all") {
+    await db.run(
+      "UPDATE notifications SET read_at = ? WHERE LOWER(user_email) = LOWER(?) AND read_at IS NULL",
+      [now, userEmail]
+    );
+    return;
+  }
+  for (const id of ids.slice(0, 200)) {
+    await db.run(
+      "UPDATE notifications SET read_at = ? WHERE id = ? AND LOWER(user_email) = LOWER(?)",
+      [now, id, userEmail]
+    );
+  }
+}
+
+// src/workflow/env-routes.ts
+import { Hono as Hono2 } from "hono";
+
+// src/governance/access-guard.ts
+async function resolveCallerEmail(userId) {
+  if (!userId) return "admin@localhost";
+  const db = getDb();
+  const row = await db.get(
+    "SELECT email FROM users WHERE id = ?",
+    [userId]
+  );
+  return row?.email || "admin@localhost";
+}
+async function canReadNode(nestId, nodeId, userId, userEmail) {
+  if (await isPublicReader(nestId, userId)) {
+    return await getApprovedVersion(nestId, nodeId) !== null;
+  }
+  if (!await isStewardshipEnabled(nestId)) return true;
+  if ((await canUserAccess(nestId, nodeId, userEmail)).allowed) return true;
+  return await resolveNodeGrant(nestId, userId, nodeId) !== null;
+}
+async function filterAccessible(nestId, userId, userEmail, nodes) {
+  if (await isPublicReader(nestId, userId)) {
+    const filtered = [];
+    for (const n of nodes) {
+      if (await getApprovedVersion(nestId, n.id) !== null) {
+        filtered.push(n);
+      }
+    }
+    return filtered;
+  }
+  if (!await isStewardshipEnabled(nestId)) return nodes;
+  const grants = await listUserGrants(nestId, userId);
+  const accessible = [];
+  for (const n of nodes) {
+    if ((await canUserAccess(nestId, n.id, userEmail)).allowed || grantCoversNode(grants, n.id)) {
+      accessible.push(n);
+    }
+  }
+  return accessible;
+}
+
+// src/workflow/edge-type-routes.ts
+import { Hono } from "hono";
+import { v4 as uuid2 } from "uuid";
+
+// src/shared/json.ts
+var safeJson = (s) => {
+  if (!s) return null;
+  try {
+    return JSON.parse(s);
+  } catch {
+    return null;
+  }
+};
+
+// src/workflow/flow-graph.ts
+async function assertFlowGraphAcyclic(nestId, extraFlowTypeId) {
+  const db = getDb();
+  const rows = await db.all(
+    `SELECT e.from_node, e.to_node FROM edges e
+       JOIN edge_types t ON t.id = e.type_id
+      WHERE e.nest_id = ? AND (t.is_flow = 1 OR t.id = ?)`,
+    [nestId, extraFlowTypeId ?? ""]
+  );
+  const adj = /* @__PURE__ */ new Map();
+  const indeg = /* @__PURE__ */ new Map();
+  const nodes = /* @__PURE__ */ new Set();
+  for (const r of rows) {
+    if (r.from_node === r.to_node) {
+      throw new ConflictError(
+        `cycle: ["${r.from_node}"] \u2014 a flow edge cannot be a self-loop`
+      );
+    }
+    nodes.add(r.from_node);
+    nodes.add(r.to_node);
+    (adj.get(r.from_node) ?? adj.set(r.from_node, []).get(r.from_node)).push(
+      r.to_node
+    );
+    indeg.set(r.to_node, (indeg.get(r.to_node) ?? 0) + 1);
+    if (!indeg.has(r.from_node)) indeg.set(r.from_node, 0);
+  }
+  const queue = [...nodes].filter((n) => (indeg.get(n) ?? 0) === 0);
+  let removed = 0;
+  while (queue.length) {
+    const cur = queue.shift();
+    removed++;
+    for (const nb of adj.get(cur) ?? []) {
+      indeg.set(nb, (indeg.get(nb) ?? 0) - 1);
+      if ((indeg.get(nb) ?? 0) === 0) queue.push(nb);
+    }
+  }
+  if (removed < nodes.size) {
+    throw new ConflictError(
+      "cycle: enabling flow on this edge type would create a cycle in the flow graph \u2014 flow edges must form a DAG"
+    );
+  }
+}
+
+// src/workflow/edge-type-routes.ts
+var requireWorkflowPlane = async (c, next) => {
+  if (!config.FEATURE_WORKFLOW_PLANE) {
+    return c.json(
+      {
+        error: "The workflow plane is not enabled on this server. An admin can turn it on with FEATURE_WORKFLOW_PLANE=true."
+      },
+      404
+    );
+  }
+  return next();
+};
+async function seedDefaultEdgeTypes(nestId) {
+  const db = getDb();
+  const existing = await db.get(
+    "SELECT COUNT(*) as c FROM edge_types WHERE nest_id = ?",
+    [nestId]
+  );
+  if (existing.c > 0) return;
+  const owner = await db.get(
+    "SELECT u.email FROM nests n JOIN users u ON u.id = n.user_id WHERE n.id = ?",
+    [nestId]
+  );
+  const createdBy = owner?.email ?? "admin@localhost";
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const defaults = [
+    ["next", "Unconditional flow: after the source completes, run the target.", 1, "#16a34a"],
+    ["on-success", "Follow only when the source step succeeded.", 1, "#16a34a"],
+    ["on-failure", "Follow only when the source step failed.", 1, "#ef4444"],
+    ["depends-on", "The source requires the target (ordering/lineage; not conditional flow).", 0, "#3b82f6"],
+    ["owned-by", "Ownership: the target person/team is accountable for the source node.", 0, "#64748b"]
+  ];
+  for (const [name, description, isFlow, color] of defaults) {
+    await db.run(
+      `INSERT INTO edge_types
+         (id, nest_id, name, description, direction, is_flow, condition_schema, color, created_by, created_at, updated_at)
+       VALUES (?, ?, ?, ?, 'directed', ?, NULL, ?, ?, ?, ?)
+       ON CONFLICT DO NOTHING`,
+      [uuid2(), nestId, name, description, isFlow, color, createdBy, now, now]
+    );
+  }
+}
+function parseConditionSchema(raw) {
+  if (raw === void 0 || raw === null || raw === "") return null;
+  const obj = typeof raw === "string" ? safeJson(raw) : raw;
+  if (!obj || typeof obj !== "object" || !Array.isArray(obj.params) || !obj.params.every((p) => typeof p === "string")) {
+    throw new ValidationError(
+      'condition_schema must be {"params": [string\u2026], "mode_default"?: "structured"|"nl"|"open"}'
+    );
+  }
+  const mode = obj.mode_default;
+  if (mode !== void 0 && !["structured", "nl", "open"].includes(mode)) {
+    throw new ValidationError(
+      "condition_schema.mode_default must be structured | nl | open"
+    );
+  }
+  return JSON.stringify({ params: obj.params, mode_default: mode ?? "structured" });
+}
+var edgeTypeToResponse = (r) => ({
+  ...r,
+  is_flow: !!r.is_flow,
+  condition_schema: r.condition_schema ? safeJson(r.condition_schema) : null
+});
+var edgeTypeRoutes = new Hono();
+edgeTypeRoutes.get("/", requireWorkflowPlane, async (c) => {
+  const nestId = c.req.param("nestId");
+  await seedDefaultEdgeTypes(nestId);
+  const rows = await getDb().all(
+    "SELECT * FROM edge_types WHERE nest_id = ? ORDER BY LOWER(name)",
+    [nestId]
+  );
+  return c.json({ count: rows.length, edge_types: rows.map(edgeTypeToResponse) });
+});
+edgeTypeRoutes.post("/", requireWorkflowPlane, async (c) => {
+  const nestId = c.req.param("nestId");
+  const body = await c.req.json();
+  if (typeof body.name !== "string" || !body.name.trim()) {
+    throw new ValidationError("name is required");
+  }
+  if (typeof body.description !== "string" || !body.description.trim()) {
+    throw new ValidationError("description (the articulation) is required");
+  }
+  const name = body.name.trim();
+  if (name.length > 100 || !/^[a-z0-9][a-z0-9-]*$/i.test(name)) {
+    throw new ValidationError(
+      "name must be alphanumeric-with-dashes, 100 chars max (e.g. escalates-when)"
+    );
+  }
+  const direction = String(body.direction ?? "directed");
+  if (!["directed", "undirected"].includes(direction)) {
+    throw new ValidationError("direction must be directed | undirected");
+  }
+  const conditionSchema = parseConditionSchema(body.condition_schema);
+  const isFlow = body.is_flow === true ? 1 : 0;
+  let color = null;
+  if (body.color !== void 0 && body.color !== null && body.color !== "") {
+    if (typeof body.color !== "string" || !/^#[0-9a-f]{6}$/i.test(body.color)) {
+      throw new ValidationError("color must be a 6-digit hex, e.g. #16a34a");
+    }
+    color = body.color;
+  }
+  const db = getDb();
+  const definedBy = await resolveCallerEmail(c.get("userId"));
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await seedDefaultEdgeTypes(nestId);
+  let created = false;
+  await db.transaction(async (tx) => {
+    const existing = await tx.get(
+      "SELECT id, is_flow FROM edge_types WHERE nest_id = ? AND LOWER(name) = LOWER(?)",
+      [nestId, name]
+    );
+    if (existing && !existing.is_flow && isFlow) {
+      await assertFlowGraphAcyclic(nestId, existing.id);
+    }
+    if (existing) {
+      await tx.run(
+        `UPDATE edge_types SET name = ?, description = ?, direction = ?, is_flow = ?,
+           condition_schema = ?, color = ?, updated_at = ? WHERE id = ?`,
+        [name, body.description.trim(), direction, isFlow, conditionSchema, color, now, existing.id]
+      );
+    } else {
+      created = true;
+      await tx.run(
+        `INSERT INTO edge_types
+           (id, nest_id, name, description, direction, is_flow, condition_schema, color, created_by, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        [uuid2(), nestId, name, body.description.trim(), direction, isFlow, conditionSchema, color, definedBy, now, now]
+      );
+    }
+  });
+  const row = await db.get(
+    "SELECT * FROM edge_types WHERE nest_id = ? AND LOWER(name) = LOWER(?)",
+    [nestId, name]
+  );
+  return c.json({ edge_type: edgeTypeToResponse(row) }, created ? 201 : 200);
+});
+edgeTypeRoutes.delete("/:id", requireWorkflowPlane, async (c) => {
+  const nestId = c.req.param("nestId");
+  const id = c.req.param("id");
+  await getDb().transaction(async (tx) => {
+    const row = await tx.get(
+      "SELECT id FROM edge_types WHERE id = ? AND nest_id = ?",
+      [id, nestId]
+    );
+    if (!row) throw new NotFoundError("Edge type not found");
+    const inUse = await tx.get(
+      "SELECT COUNT(*) as c FROM edges WHERE type_id = ?",
+      [id]
+    );
+    if (inUse.c > 0) {
+      throw new ValidationError(
+        `Edge type is in use by ${inUse.c} edge${inUse.c === 1 ? "" : "s"} \u2014 delete those first.`
+      );
+    }
+    await tx.run("DELETE FROM edge_types WHERE id = ?", [id]);
+  });
+  return c.json({ deleted: true });
+});
+
+// src/workflow/env-routes.ts
+var KEY_RE = /^[A-Z][A-Z0-9_]{0,63}$/;
+var mask = (v) => v.length <= 4 ? "\u2022\u2022\u2022\u2022" : `\u2022\u2022\u2022\u2022${v.slice(-4)}`;
+var envRoutes = new Hono2();
+envRoutes.get("/", requireWorkflowPlane, async (c) => {
+  const nestId = c.req.param("nestId");
+  const rows = await getDb().all(
+    "SELECT key, value, updated_by, updated_at FROM nest_env WHERE nest_id = ? ORDER BY key",
+    [nestId]
+  );
+  return c.json({
+    count: rows.length,
+    env: rows.map((r) => ({
+      key: r.key,
+      value_masked: mask(r.value),
+      updated_by: r.updated_by,
+      updated_at: r.updated_at
+    }))
+  });
+});
+envRoutes.put("/", requireWorkflowPlane, async (c) => {
+  const nestId = c.req.param("nestId");
+  const body = await c.req.json();
+  const key = typeof body.key === "string" ? body.key.trim() : "";
+  if (!KEY_RE.test(key)) {
+    throw new ValidationError(
+      "key must look like an env var: A-Z, digits, underscores (e.g. SLACK_TOKEN)"
+    );
+  }
+  if (typeof body.value !== "string" || !body.value) {
+    throw new ValidationError("value is required");
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const by = await resolveCallerEmail(c.get("userId"));
+  const db = getDb();
+  await db.run(
+    `INSERT INTO nest_env (nest_id, key, value, updated_by, updated_at)
+     VALUES (?, ?, ?, ?, ?)
+     ON CONFLICT(nest_id, key) DO UPDATE SET value = ?, updated_by = ?, updated_at = ?`,
+    [nestId, key, body.value, by, now, body.value, by, now]
+  );
+  return c.json({ key, value_masked: mask(body.value) }, 201);
+});
+envRoutes.delete("/:key", requireWorkflowPlane, async (c) => {
+  const nestId = c.req.param("nestId");
+  const key = c.req.param("key");
+  const db = getDb();
+  const row = await db.get(
+    "SELECT key FROM nest_env WHERE nest_id = ? AND key = ?",
+    [nestId, key]
+  );
+  if (!row) throw new NotFoundError("No such env key");
+  await db.run("DELETE FROM nest_env WHERE nest_id = ? AND key = ?", [nestId, key]);
+  return c.json({ deleted: true });
+});
+async function envValues(nestId) {
+  const rows = await getDb().all(
+    "SELECT key, value FROM nest_env WHERE nest_id = ?",
+    [nestId]
+  );
+  const base = {};
+  if (process.env.ANTHROPIC_API_KEY) base.ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY;
+  return { ...base, ...Object.fromEntries(rows.map((r) => [r.key, r.value])) };
+}
+
+// src/notify/dispatch.ts
+function escapeMrkdwn(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+var EVENT_EMOJI = {
+  review_requested: ":memo:",
+  review_approved: ":white_check_mark:",
+  review_rejected: ":x:",
+  run_failed: ":rotating_light:"
+};
+function formatBody(channel, nestName, ev) {
+  const line = `[${nestName}] ${ev.message}`;
+  if (channel === "slack") {
+    return { text: escapeMrkdwn(`${EVENT_EMOJI[ev.kind] ?? ""} *[${nestName}]* ${ev.message}`) };
+  }
+  if (channel === "teams") {
+    return { text: line };
+  }
+  return {
+    kind: ev.kind,
+    nest_id: ev.nestId,
+    nest_name: nestName,
+    message: ev.message,
+    subject_id: ev.subjectId ?? null,
+    actor: ev.actor ?? null,
+    at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function isForbiddenConnectorHost(hostname) {
+  const h = hostname.toLowerCase().replace(/^\[|\]$/g, "");
+  if (h === "localhost" || h.endsWith(".localhost") || h.endsWith(".local") || h.endsWith(".internal"))
+    return true;
+  if (h === "::1" || h === "0.0.0.0" || h.startsWith("fe80:") || h.startsWith("fc") || h.startsWith("fd"))
+    return true;
+  const m = h.match(/^(\d+)\.(\d+)\.(\d+)\.(\d+)$/);
+  if (!m) return false;
+  const [a, b] = [Number(m[1]), Number(m[2])];
+  if (a === 127 || a === 10 || a === 0) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 169 && b === 254) return true;
+  return false;
+}
+function isSafeConnectorUrl(raw) {
+  if (!/^https:\/\//i.test(raw)) return false;
+  try {
+    return !isForbiddenConnectorHost(new URL(raw).hostname);
+  } catch {
+    return false;
+  }
+}
+async function resolveUrl(nestId, raw) {
+  if (raw.startsWith("env:")) {
+    const key = raw.slice(4).trim();
+    const env = await envValues(nestId);
+    const v = env[key];
+    return v && isSafeConnectorUrl(v) ? v : null;
+  }
+  return isSafeConnectorUrl(raw) ? raw : null;
+}
+var warned = /* @__PURE__ */ new Set();
+async function post(url, body, who) {
+  try {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), 3e3);
+    try {
+      await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal: ctrl.signal
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+  } catch (err) {
+    if (!warned.has(who)) {
+      warned.add(who);
+      console.warn(
+        `[connectors] delivery failed for ${who} (muting further warnings):`,
+        err instanceof Error ? err.message : err
+      );
+    }
+  }
+}
+async function dispatchEvent(ev) {
+  const db = getDb();
+  let nestName = ev.nestId;
+  try {
+    const row = await db.get("SELECT name FROM nests WHERE id = ?", [ev.nestId]);
+    if (row?.name) nestName = row.name;
+  } catch {
+  }
+  if (config.SLACK_WEBHOOK_URL) {
+    void post(
+      config.SLACK_WEBHOOK_URL,
+      formatBody("slack", nestName, ev),
+      "server-slack"
+    );
+  }
+  let rows = [];
+  try {
+    rows = await db.all(
+      "SELECT id, channel, url, events, enabled FROM connectors WHERE nest_id = ? AND enabled = 1",
+      [ev.nestId]
+    );
+  } catch {
+    return;
+  }
+  for (const r of rows) {
+    let kinds = [];
+    try {
+      kinds = JSON.parse(r.events);
+    } catch {
+    }
+    if (!kinds.includes("*") && !kinds.includes(ev.kind)) continue;
+    const url = await resolveUrl(ev.nestId, r.url);
+    if (!url) continue;
+    void post(url, formatBody(r.channel, nestName, ev), `connector:${r.id}`);
+  }
+}
+
+// src/notify/slack.ts
+var warnedOnce = false;
+async function notifySlackForNest(nestId, message) {
+  if (!config.SLACK_WEBHOOK_URL) return;
+  let nestName = nestId;
+  try {
+    const row = await getDb().get("SELECT name FROM nests WHERE id = ?", [
+      nestId
+    ]);
+    if (row?.name) nestName = row.name;
+  } catch {
+  }
+  return notifySlack(`*[${nestName}]* ${message}`);
+}
+function escapeMrkdwn2(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+async function notifySlack(text) {
+  const url = config.SLACK_WEBHOOK_URL;
+  if (!url) return;
+  try {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), 3e3);
+    try {
+      await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ text: escapeMrkdwn2(text) }),
+        signal: ctrl.signal
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+  } catch (err) {
+    if (!warnedOnce) {
+      warnedOnce = true;
+      console.warn(
+        "[slack] notification failed (suppressing further warnings):",
+        err instanceof Error ? err.message : err
+      );
+    }
+  }
+}
+
+// src/notify/email-render.ts
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+var EVENT = {
+  ":white_check_mark:": { icon: "\u2705", color: "#16a34a" },
+  ":x:": { icon: "\u274C", color: "#dc2626" },
+  ":memo:": { icon: "\u{1F4DD}", color: "#d97706" },
+  ":key:": { icon: "\u{1F511}", color: "#2563eb" }
+};
+var ALL_EMOJI = Object.fromEntries(
+  Object.entries(EVENT).map(([code, m]) => [code, m.icon])
+);
+function renderText(message) {
+  return message.replace(/:[a-z_]+:/g, (m) => ALL_EMOJI[m] ?? "").replace(/\*/g, "").replace(/[ \t]{2,}/g, " ").trim();
+}
+var STATUS_META = {
+  approved: { subjectWord: "approved", label: "Approved", color: "#16a34a" },
+  rejected: { subjectWord: "rejected", label: "Rejected", color: "#dc2626" },
+  pending_review: {
+    subjectWord: "awaiting review",
+    label: "Pending review",
+    color: "#d97706"
+  },
+  shared: { subjectWord: "shared with you", label: "Shared", color: "#2563eb" }
+};
+function renderEmail(d) {
+  const meta = STATUS_META[d.status];
+  const title = d.docTitle.replace(/[\r\n]+/g, " ").trim();
+  const heading = d.status === "shared" ? `New collaborator on ${title}` : `${title} is ${meta.subjectWord}`;
+  const subject = heading.replace(/[\r\n]+/g, " ").trim();
+  const vLabel = d.version != null ? `v${d.version}` : "";
+  const detailsHeader = d.status === "shared" ? "Details" : "Document details";
+  const linkLabel = d.status === "shared" ? "Open nest" : "Open document";
+  const byT = d.actor ? ` by ${d.actor}` : "";
+  const noteT = d.note ? ` with the note: "${d.note}"` : "";
+  const vT = vLabel ? ` ${vLabel}` : "";
+  let lineT;
+  switch (d.status) {
+    case "approved":
+      lineT = `${title}${vT} has been approved${byT}${noteT}.`;
+      break;
+    case "rejected":
+      lineT = `${title}${vT} has been rejected${byT}${noteT}.`;
+      break;
+    case "pending_review":
+      lineT = `A review has been requested for ${title}${vT}${byT}${noteT}.`;
+      break;
+    case "shared":
+      lineT = `${d.actor || "A user"} was added to ${title} as ${d.permission || "a collaborator"}${d.by ? ` by ${d.by}` : ""}.`;
+      break;
+  }
+  const text = [
+    "Hi,",
+    "",
+    lineT,
+    "",
+    "Document details:",
+    `  Path: ${d.path}`,
+    `  Status: ${meta.label}`,
+    ...d.version != null ? [`  Version: v${d.version}`] : [],
+    ...d.link ? [`  Open: ${d.link}`] : [],
+    "",
+    "Regards,",
+    "ContextNest"
+  ].join("\n");
+  const doc = `<strong>${escapeHtml(title)}</strong>`;
+  const byH = d.actor ? ` by ${escapeHtml(d.actor)}` : "";
+  const noteH = d.note ? ` with the note: &ldquo;${escapeHtml(d.note)}&rdquo;` : "";
+  const vH = vLabel ? ` ${vLabel}` : "";
+  let lineH;
+  switch (d.status) {
+    case "approved":
+      lineH = `${doc}${vH} has been approved${byH}${noteH}.`;
+      break;
+    case "rejected":
+      lineH = `${doc}${vH} has been rejected${byH}${noteH}.`;
+      break;
+    case "pending_review":
+      lineH = `A review has been requested for ${doc}${vH}${byH}${noteH}.`;
+      break;
+    case "shared":
+      lineH = `${escapeHtml(d.actor || "A user")} was added to ${doc} as <strong>${escapeHtml(d.permission || "a collaborator")}</strong>${d.by ? ` by ${escapeHtml(d.by)}` : ""}.`;
+      break;
+  }
+  const detailRow = (label, valueHtml) => `<tr>
+      <td style="padding:5px 0;font-size:13px;color:#6b7280;width:90px;vertical-align:top;">${label}</td>
+      <td style="padding:5px 0;font-size:13px;color:#111827;vertical-align:top;">${valueHtml}</td>
+    </tr>`;
+  const detailRows = detailRow("Path", escapeHtml(d.path)) + detailRow(
+    "Status",
+    `<span style="display:inline-block;padding:2px 9px;border-radius:9999px;background:#f3f4f6;color:${meta.color};font-size:12px;font-weight:600;">${meta.label}</span>`
+  ) + (d.version != null ? detailRow("Version", `v${d.version}`) : "");
+  const buttonRow = d.link ? `<tr><td style="padding:20px 24px 0;">
+        <table role="presentation" cellpadding="0" cellspacing="0" border="0"><tr>
+          <td bgcolor="${meta.color}" style="border-radius:6px;">
+            <a href="${escapeHtml(d.link)}" target="_blank" style="display:inline-block;padding:10px 20px;font-size:14px;font-weight:600;color:#ffffff;text-decoration:none;">${linkLabel}</a>
+          </td>
+        </tr></table>
+      </td></tr>` : "";
+  const html = `<div style="margin:0;padding:24px;background:#f6f8fa;font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,Helvetica,Arial,sans-serif;color:#111827;">
+  <table role="presentation" width="480" cellpadding="0" cellspacing="0" border="0" align="center" style="width:100%;max-width:480px;margin:0 auto;background:#ffffff;border:1px solid #e5e7eb;border-radius:12px;">
+    <tr><td style="padding:20px 24px 0;">
+      <div style="font-size:12px;font-weight:700;color:#6b7280;letter-spacing:0.06em;text-transform:uppercase;">ContextNest</div>
+    </td></tr>
+    <tr><td style="padding:10px 24px 0;">
+      <h1 style="margin:0;font-size:19px;line-height:1.35;font-weight:700;color:#111827;">${escapeHtml(heading)}</h1>
+    </td></tr>
+    <tr><td style="padding:16px 24px 0;font-size:14px;line-height:1.6;color:#374151;">
+      Hi,<br><br>${lineH}
+    </td></tr>
+    <tr><td style="padding:20px 24px 0;">
+      <table role="presentation" width="100%" cellpadding="0" cellspacing="0" border="0" style="border:1px solid #eef0f2;border-radius:8px;">
+        <tr><td style="padding:12px 16px;">
+          <div style="font-size:11px;font-weight:600;color:#9ca3af;letter-spacing:0.04em;text-transform:uppercase;padding-bottom:4px;">${detailsHeader}</div>
+          <table role="presentation" width="100%" cellpadding="0" cellspacing="0" border="0">${detailRows}</table>
+        </td></tr>
+      </table>
+    </td></tr>
+    ${buttonRow}
+    <tr><td style="padding:22px 24px 24px;font-size:14px;line-height:1.6;color:#374151;">
+      Regards,<br>ContextNest
+    </td></tr>
+    <tr><td style="padding:14px 24px;border-top:1px solid #f0f0f0;font-size:11px;line-height:1.5;color:#9ca3af;">
+      Automated governance notification from ContextNest. You received this because email notifications are enabled on this server.
+    </td></tr>
+  </table>
+</div>`;
+  return { subject, text, html };
+}
+function renderHtml(message, nestName) {
+  const lead = message.match(/^(:[a-z_]+:)\s*/);
+  const meta = lead && EVENT[lead[1]] || { icon: "\u{1F514}", color: "#475569" };
+  const rest = lead ? message.slice(lead[0].length) : message;
+  const body = escapeHtml(rest).replace(/\*([^*]+)\*/g, "<strong>$1</strong>").replace(/\n/g, "<br>");
+  const safeNest = escapeHtml(nestName);
+  return `<div style="background:#f6f8fa;padding:24px;font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,Helvetica,Arial,sans-serif;">
+  <table role="presentation" width="100%" cellpadding="0" cellspacing="0" style="max-width:480px;margin:0 auto;background:#ffffff;border:1px solid #e5e7eb;border-radius:12px;overflow:hidden;">
+    <tr><td style="padding:20px 24px 16px;border-bottom:1px solid #f0f0f0;">
+      <div style="font-size:15px;font-weight:700;color:#111827;letter-spacing:-0.01em;">ContextNest</div>
+      <div style="font-size:13px;color:#6b7280;margin-top:2px;">${safeNest}</div>
+    </td></tr>
+    <tr><td style="padding:24px;">
+      <table role="presentation" cellpadding="0" cellspacing="0"><tr>
+        <td valign="top" style="font-size:22px;line-height:1;padding-right:14px;">${meta.icon}</td>
+        <td valign="top" style="font-size:15px;line-height:1.55;color:#111827;border-left:3px solid ${meta.color};padding-left:14px;">${body}</td>
+      </tr></table>
+    </td></tr>
+    <tr><td style="padding:14px 24px;border-top:1px solid #f0f0f0;font-size:11px;line-height:1.5;color:#9ca3af;">
+      Automated governance notification from ContextNest. You received this because email notifications are enabled on this server.
+    </td></tr>
+  </table>
+</div>`;
+}
+
+// src/notify/email.ts
+var transporterPromise = null;
+var configuredUrl = null;
+var warnedOnce2 = false;
+var SMTP_TIMEOUT_DEFAULTS = [
+  ["connectionTimeout", 5e3],
+  ["greetingTimeout", 5e3],
+  ["socketTimeout", 1e4]
+];
+function withTimeouts(url) {
+  const query = url.includes("?") ? url.slice(url.indexOf("?") + 1) : "";
+  const missing = SMTP_TIMEOUT_DEFAULTS.filter(
+    ([name]) => !new RegExp(`(^|&)${name}=`, "i").test(query)
+  ).map(([name, ms]) => `${name}=${ms}`);
+  if (missing.length === 0) return url;
+  return url + (url.includes("?") ? "&" : "?") + missing.join("&");
+}
+async function verifySmtp(url) {
+  let transporter = null;
+  try {
+    const nodemailer = await import("nodemailer");
+    transporter = nodemailer.default.createTransport(withTimeouts(url), {
+      disableFileAccess: true,
+      disableUrlAccess: true
+    });
+    await transporter.verify();
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  } finally {
+    try {
+      transporter?.close?.();
+    } catch {
+    }
+  }
+}
+async function getTransporter() {
+  const url = config.SMTP_URL;
+  if (!url) return null;
+  if (!transporterPromise || configuredUrl !== url) {
+    configuredUrl = url;
+    transporterPromise = import("nodemailer").then(
+      (nodemailer) => nodemailer.default.createTransport(withTimeouts(url), {
+        // Per-message defaults (belt-and-braces; also set on each sendMail).
+        disableFileAccess: true,
+        disableUrlAccess: true
+      })
+    );
+    transporterPromise.catch(() => {
+      transporterPromise = null;
+      configuredUrl = null;
+    });
+  }
+  return transporterPromise;
+}
+async function notifyEmailForNest(nestId, message, details) {
+  const from = config.NOTIFY_EMAIL_FROM;
+  const to = config.NOTIFY_EMAIL_TO;
+  if (!config.SMTP_URL || !from || !to) return;
+  try {
+    const transporter = await getTransporter();
+    if (!transporter) return;
+    let subject;
+    let text;
+    let html;
+    if (details) {
+      ({ subject, text, html } = renderEmail(details));
+    } else {
+      let name = nestId;
+      try {
+        const row = await getDb().get("SELECT name FROM nests WHERE id = ?", [
+          nestId
+        ]);
+        if (row?.name) name = row.name;
+      } catch {
+      }
+      const safeName = name.replace(/[\r\n]+/g, " ").trim();
+      subject = `ContextNest \xB7 ${safeName}`;
+      text = renderText(message);
+      html = renderHtml(message, safeName);
+    }
+    await transporter.sendMail({
+      from,
+      to,
+      subject,
+      text,
+      html,
+      disableFileAccess: true,
+      disableUrlAccess: true
+    });
+  } catch (err) {
+    if (!warnedOnce2) {
+      warnedOnce2 = true;
+      console.warn(
+        "[email] notification failed (suppressing further warnings):",
+        err instanceof Error ? err.message : err
+      );
+    }
+  }
+}
+
+// src/notify/notify.ts
+var DIGEST_LINE_CAP = 10;
+var buffers = /* @__PURE__ */ new Map();
+function buildText(lines) {
+  if (lines.length === 1) return lines[0];
+  const shown = lines.slice(0, DIGEST_LINE_CAP).map((l) => `\u2022 ${l}`).join("\n");
+  const more = lines.length > DIGEST_LINE_CAP ? `
+\u2026and ${lines.length - DIGEST_LINE_CAP} more` : "";
+  return `${lines.length} updates:
+${shown}${more}`;
+}
+async function flush(nestId) {
+  const buf = buffers.get(nestId);
+  if (!buf) return;
+  buffers.delete(nestId);
+  const text = buildText(buf.events.map((e) => e.line));
+  const details = buf.events.length === 1 ? buf.events[0].details : void 0;
+  await Promise.allSettled([
+    notifySlackForNest(nestId, text),
+    notifyEmailForNest(nestId, text, details)
+  ]);
+}
+async function notifyNestEvent(nestId, message, details) {
+  if (!config.SLACK_WEBHOOK_URL && !config.SMTP_URL) return;
+  const buf = buffers.get(nestId);
+  if (buf) {
+    buf.events.push({ line: message, details });
+    return;
+  }
+  const timer = setTimeout(() => void flush(nestId), config.NOTIFY_DEBOUNCE_MS);
+  timer.unref?.();
+  buffers.set(nestId, { events: [{ line: message, details }], timer });
+}
+
+// src/governance/safe-publish.ts
+import {
+  publishDocument,
+  serializeDocument
+} from "@promptowl/contextnest-engine";
+async function safePublishDocument(storage, docId, options) {
+  const node = await storage.readDocument(docId);
+  const cleanedFrontmatter = stripUndefinedDeep(node.frontmatter);
+  const cleanedNode = { ...node, frontmatter: cleanedFrontmatter };
+  await storage.writeDocument(docId, serializeDocument(cleanedNode));
+  return publishDocument(storage, docId, options);
+}
+function stripUndefinedDeep(value) {
+  if (Array.isArray(value)) {
+    return value.filter((v) => v !== void 0).map((v) => stripUndefinedDeep(v));
+  }
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      if (v === void 0) continue;
+      out[k] = stripUndefinedDeep(v);
+    }
+    return out;
+  }
+  return value;
+}
+
+// src/governance/review-service.ts
+async function submitForReview(params) {
+  const db = getDb();
+  const existing = await db.get(
+    "SELECT id FROM review_requests WHERE nest_id = ? AND node_id = ? AND status = 'pending'",
+    [params.nestId, params.nodeId]
+  );
+  if (existing) {
+    throw new Error("A review is already pending for this node");
+  }
+  const id = uuid3();
+  await db.run(
+    `INSERT INTO review_requests
+     (id, nest_id, node_id, version, requested_by, request_note, priority)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    [
+      id,
+      params.nestId,
+      params.nodeId,
+      params.version,
+      params.requestedBy,
+      params.note || null,
+      params.priority || "normal"
+    ]
+  );
+  await db.run(
+    "UPDATE node_versions SET status = 'pending_review' WHERE nest_id = ? AND node_id = ? AND version = ?",
+    [params.nestId, params.nodeId, params.version]
+  );
+  const reviewCtx = await buildDocContext(params.nestId, params.nodeId, params.baseUrl);
+  void dispatchEvent({
+    kind: "review_requested",
+    nestId: params.nestId,
+    subjectId: params.nodeId,
+    actor: params.requestedBy,
+    message: `Review requested on *${reviewCtx.label}* (v${params.version}) by ${params.requestedBy}${params.note ? ` \u2014 "${params.note}"` : ""}`
+  });
+  void notifyNestEvent(
+    params.nestId,
+    `:memo: Review requested on *${reviewCtx.label}* (v${params.version}) by ${params.requestedBy}${params.note ? ` \u2014 "${params.note}"` : ""}`,
+    {
+      status: "pending_review",
+      docTitle: reviewCtx.docTitle,
+      path: reviewCtx.path,
+      link: reviewCtx.link,
+      actor: params.requestedBy,
+      version: params.version,
+      note: params.note || null
+    }
+  );
+  await notifyReviewRequested({
+    nestId: params.nestId,
+    nodeId: params.nodeId,
+    requestedBy: params.requestedBy,
+    reviewId: id
+  });
+  return await getReviewRequest(id);
+}
+async function approve(params) {
+  const db = getDb();
+  const pending = await db.get(
+    "SELECT * FROM review_requests WHERE nest_id = ? AND node_id = ? AND status = 'pending' ORDER BY requested_at DESC LIMIT 1",
+    [params.nestId, params.nodeId]
+  );
+  if (!pending) {
+    throw new Error("No pending review for this node");
+  }
+  if (!params.override) {
+    const check = await canUserApprove(
+      params.nestId,
+      params.nodeId,
+      params.approvedBy
+    );
+    if (!check.allowed) {
+      throw new Error(check.reason);
+    }
+  }
+  await db.run(
+    `UPDATE review_requests
+     SET status = 'approved', resolved_by = ?, resolved_at = ${nowExpr(db)},
+         resolution_note = ?, is_override = ?
+     WHERE id = ?`,
+    [params.approvedBy, params.note || null, params.override ? 1 : 0, pending.id]
+  );
+  void dispatchEvent({
+    kind: "review_approved",
+    nestId: params.nestId,
+    subjectId: params.nodeId,
+    actor: params.approvedBy,
+    message: `*${await describeNode(params.nestId, params.nodeId)}* v${params.version} approved by ${params.approvedBy}`
+  });
+  await notifyReviewResolved({
+    nestId: params.nestId,
+    nodeId: params.nodeId,
+    status: "approved",
+    resolvedBy: params.approvedBy,
+    requestedBy: pending.requested_by,
+    reviewId: pending.id
+  });
+  await db.run(
+    "UPDATE node_versions SET status = 'published' WHERE nest_id = ? AND node_id = ? AND version = ?",
+    [params.nestId, params.nodeId, params.version]
+  );
+  await db.run(
+    insertOrReplace(
+      db,
+      `INSERT INTO approved_versions (nest_id, node_id, approved_version, approved_by)
+       VALUES (?, ?, ?, ?)`,
+      ["nest_id", "node_id"],
+      `approved_version = excluded.approved_version, approved_by = excluded.approved_by, approved_at = ${nowExpr(db)}`
+    ),
+    [params.nestId, params.nodeId, params.version, params.approvedBy]
+  );
+  try {
+    const { storage } = await engineCache.get(params.nestId);
+    const result = await safePublishDocument(storage, params.nodeId, {
+      editedBy: params.approvedBy,
+      note: params.note || `Approved review request ${pending.id}`
+    });
+    const engineVersion = result.versionEntry.version;
+    if (engineVersion !== params.version) {
+      const node = result.node;
+      const tags = node.frontmatter.tags || [];
+      await createVersion({
+        nestId: params.nestId,
+        nodeId: params.nodeId,
+        version: engineVersion,
+        content: node.body || "",
+        author: params.approvedBy,
+        status: "published",
+        tags,
+        changeNote: params.note || `Approved review request ${pending.id}`
+      });
+      await setApprovedVersion(
+        params.nestId,
+        params.nodeId,
+        engineVersion,
+        params.approvedBy
+      );
+    }
+  } catch (err) {
+    console.error(
+      `publishDocument failed for ${params.nestId}/${params.nodeId} on approve:`,
+      err
+    );
+  }
+  const approveCtx = await buildDocContext(params.nestId, params.nodeId, params.baseUrl);
+  void notifyNestEvent(
+    params.nestId,
+    `:white_check_mark: *${approveCtx.label}* v${params.version} approved by ${params.approvedBy}`,
+    {
+      status: "approved",
+      docTitle: approveCtx.docTitle,
+      path: approveCtx.path,
+      link: approveCtx.link,
+      actor: params.approvedBy,
+      version: params.version
+    }
+  );
+  return await getReviewRequest(pending.id);
+}
+async function reject(params) {
+  const db = getDb();
+  const pending = await db.get(
+    "SELECT * FROM review_requests WHERE nest_id = ? AND node_id = ? AND status = 'pending' ORDER BY requested_at DESC LIMIT 1",
+    [params.nestId, params.nodeId]
+  );
+  if (!pending) {
+    throw new Error("No pending review for this node");
+  }
+  const check = await canUserApprove(
+    params.nestId,
+    params.nodeId,
+    params.rejectedBy
+  );
+  if (!check.allowed) {
+    throw new Error(check.reason);
+  }
+  await db.run(
+    `UPDATE review_requests
+     SET status = 'rejected', resolved_by = ?, resolved_at = ${nowExpr(db)}, resolution_note = ?
+     WHERE id = ?`,
+    [params.rejectedBy, params.note, pending.id]
+  );
+  await db.run(
+    "UPDATE node_versions SET status = 'rejected' WHERE nest_id = ? AND node_id = ? AND version = ?",
+    [params.nestId, params.nodeId, params.version]
+  );
+  const rejectCtx = await buildDocContext(params.nestId, params.nodeId, params.baseUrl);
+  void dispatchEvent({
+    kind: "review_rejected",
+    nestId: params.nestId,
+    subjectId: params.nodeId,
+    actor: params.rejectedBy,
+    message: `*${rejectCtx.label}* v${params.version} rejected by ${params.rejectedBy}${params.note ? ` \u2014 "${params.note}"` : ""}`
+  });
+  void notifyNestEvent(
+    params.nestId,
+    `:x: *${rejectCtx.label}* v${params.version} rejected by ${params.rejectedBy} \u2014 "${params.note}"`,
+    {
+      status: "rejected",
+      docTitle: rejectCtx.docTitle,
+      path: rejectCtx.path,
+      link: rejectCtx.link,
+      actor: params.rejectedBy,
+      version: params.version,
+      note: params.note || null
+    }
+  );
+  await notifyReviewResolved({
+    nestId: params.nestId,
+    nodeId: params.nodeId,
+    status: "rejected",
+    resolvedBy: params.rejectedBy,
+    requestedBy: pending.requested_by,
+    reviewId: pending.id
+  });
+  return await getReviewRequest(pending.id);
+}
+async function cancelReview(params) {
+  const db = getDb();
+  const pending = await db.get(
+    "SELECT * FROM review_requests WHERE nest_id = ? AND node_id = ? AND status = 'pending' ORDER BY requested_at DESC LIMIT 1",
+    [params.nestId, params.nodeId]
+  );
+  if (!pending) return null;
+  await db.run(
+    `UPDATE review_requests
+     SET status = 'cancelled', resolved_by = ?, resolved_at = ${nowExpr(db)}
+     WHERE id = ?`,
+    [params.cancelledBy, pending.id]
+  );
+  await db.run(
+    "UPDATE node_versions SET status = 'draft' WHERE nest_id = ? AND node_id = ? AND version = ?",
+    [params.nestId, params.nodeId, pending.version]
+  );
+  return await getReviewRequest(pending.id);
+}
+async function getReviewQueue(params) {
+  const db = getDb();
+  let whereClauses = [];
+  const args = [];
+  if (params.nestId) {
+    whereClauses.push("nest_id = ?");
+    args.push(params.nestId);
+  }
+  if (params.status) {
+    const statuses = Array.isArray(params.status) ? params.status : [params.status];
+    whereClauses.push(
+      `status IN (${statuses.map(() => "?").join(",")})`
+    );
+    args.push(...statuses);
+  }
+  const where = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
+  const total = (await db.get(
+    `SELECT COUNT(*) as c FROM review_requests ${where}`,
+    args
+  )).c;
+  const limit = params.limit || 50;
+  const offset = params.offset || 0;
+  const rows = await db.all(
+    `SELECT * FROM review_requests ${where}
+       ORDER BY
+         CASE priority WHEN 'urgent' THEN 0 WHEN 'high' THEN 1 WHEN 'normal' THEN 2 ELSE 3 END,
+         requested_at DESC
+       LIMIT ? OFFSET ?`,
+    [...args, limit, offset]
+  );
+  let requests = rows.map(rowToReviewRequest);
+  if (params.stewardEmail) {
+    const filtered = [];
+    for (const r of requests) {
+      const stewards = await resolveStewardsForNode(r.nestId, r.nodeId);
+      if (stewards.some((s) => s.steward.userEmail === params.stewardEmail)) {
+        filtered.push(r);
+      }
+    }
+    requests = filtered;
+  }
+  const titleMapsByNest = /* @__PURE__ */ new Map();
+  const nestIds = new Set(requests.map((r) => r.nestId));
+  for (const nid of nestIds) {
+    titleMapsByNest.set(nid, await buildTitleMap(nid));
+  }
+  requests = requests.map((r) => ({
+    ...r,
+    title: titleMapsByNest.get(r.nestId)?.get(r.nodeId)
+  }));
+  return { requests, total };
+}
+async function getReviewHistory(nestId, nodeId) {
+  const db = getDb();
+  const rows = await db.all(
+    "SELECT * FROM review_requests WHERE nest_id = ? AND node_id = ? ORDER BY requested_at DESC",
+    [nestId, nodeId]
+  );
+  return rows.map(rowToReviewRequest);
+}
+async function getPendingReview(nestId, nodeId) {
+  const db = getDb();
+  const row = await db.get(
+    "SELECT * FROM review_requests WHERE nest_id = ? AND node_id = ? AND status = 'pending' ORDER BY requested_at DESC LIMIT 1",
+    [nestId, nodeId]
+  );
+  return row ? rowToReviewRequest(row) : null;
+}
+async function getReviewRequest(id) {
+  const db = getDb();
+  const row = await db.get(
+    "SELECT * FROM review_requests WHERE id = ?",
+    [id]
+  );
+  return row ? rowToReviewRequest(row) : null;
+}
+function rowToReviewRequest(row) {
+  return {
+    id: row.id,
+    nestId: row.nest_id,
+    nodeId: row.node_id,
+    version: row.version,
+    requestedBy: row.requested_by,
+    requestedAt: row.requested_at,
+    requestNote: row.request_note || void 0,
+    status: row.status,
+    resolvedBy: row.resolved_by || void 0,
+    resolvedAt: row.resolved_at || void 0,
+    resolutionNote: row.resolution_note || void 0,
+    priority: row.priority
+  };
+}
+
+export {
+  safePublishDocument,
+  listWatchers,
+  addWatcher,
+  removeWatcher,
+  listNotifications,
+  markNotificationsRead,
+  resolveCallerEmail,
+  canReadNode,
+  filterAccessible,
+  safeJson,
+  requireWorkflowPlane,
+  seedDefaultEdgeTypes,
+  parseConditionSchema,
+  edgeTypeToResponse,
+  edgeTypeRoutes,
+  envRoutes,
+  envValues,
+  isSafeConnectorUrl,
+  dispatchEvent,
+  verifySmtp,
+  notifyNestEvent,
+  submitForReview,
+  approve,
+  reject,
+  cancelReview,
+  getReviewQueue,
+  getReviewHistory,
+  getPendingReview
+};