@promptowl/contextnest-community 1.15.0 → 1.17.0

package/dist/index.js

@@ -3,6 +3,7 @@ import {
   addWatcher,
   approve,
   canReadNode,
+  canRequestDeletion,
   cancelReview,
   declineDeletion,
   deletionTargetTitle,
@@ -35,23 +36,21 @@ import {
   requireWorkflowPlane,
   resolveCallerEmail,
   safeJson,
-  safePublishDocument,
   seedDefaultEdgeTypes,
   sendTestNotification,
-  serializeNodeSafe,
-  stripUndefinedDeep,
   submitForReview,
-  withNodeWriteLock
-} from "./chunk-C4U75IUR.js";
+  withNodeWriteLock,
+  withdrawDeletionRequest
+} from "./chunk-4YGJSUJC.js";
 import {
   createGrant,
   deleteGrant,
   grantCoversNode,
-  hasAnyGrant,
+  grantRoleForNode,
   listGrants,
   listUserGrants,
   resolveNodeGrant
-} from "./chunk-5IAKUUZF.js";
+} from "./chunk-HWDPCPYT.js";
 import {
   generateApiKey,
   getKeyPrefix,
@@ -64,13 +63,15 @@ import {
   checkConflict,
   createVersion,
   getApprovedVersion,
+  getApprovedVersions,
   getCurrentVersion,
   getDisplayStatus,
+  getTrackedNodeIds,
   getVersions,
   listMyDrafts,
   setApprovedVersion,
   upsertVersion
-} from "./chunk-JWVZ3T35.js";
+} from "./chunk-UXJSO54R.js";
 import {
   canCreateInNest,
   canManageStewards,
@@ -90,7 +91,7 @@ import {
   resolveUserRoles,
   syncFromConfig,
   updateSteward
-} from "./chunk-GWDOLYFJ.js";
+} from "./chunk-YF4OFT2V.js";
 import {
   addMember,
   buildTitleMap,
@@ -101,6 +102,7 @@ import {
   deleteTeam,
   disableStewardshipAndWipeGovernance,
   docLink,
+  engineApi,
   engineCache,
   findTeamByExternalId,
   folderForNode,
@@ -136,6 +138,7 @@ import {
   nestStorageRoot,
   normalizeTag,
   nowExpr,
+  opContext,
   permissionLevel,
   persistSetting,
   removeMember,
@@ -144,6 +147,7 @@ import {
   renameTeam,
   replaceTeamRoster,
   resolveMemberIdentity,
+  resolveNestAccess,
   resolveNestPath,
   resolveNestPermission,
   sendEmailToRecipient,
@@ -161,7 +165,7 @@ import {
   updateMemberRole,
   validateLicense,
   verifySmtp
-} from "./chunk-7BOG3S5H.js";
+} from "./chunk-SNFGU5Q7.js";
 import {
   AppError,
   ConflictError,
@@ -177,7 +181,7 @@ import {
   initDb,
   isEmailListish,
   isEmailish
-} from "./chunk-BCFKLY4H.js";
+} from "./chunk-JMJLNEXE.js";
 import {
   ANON_EMAIL,
   ANON_USER_ID
@@ -195,6 +199,29 @@ import { LinearRouter } from "hono/router/linear-router";
 import { createMiddleware as createMiddleware2 } from "hono/factory";
 import { cors } from "hono/cors";
 
+// src/shared/artifact-sandbox.ts
+var ARTIFACT_SANDBOX_CSP = [
+  "sandbox allow-scripts allow-popups allow-modals",
+  "default-src 'none'",
+  "script-src 'unsafe-inline'",
+  "style-src 'unsafe-inline'",
+  "img-src data: blob:",
+  "font-src data:",
+  "connect-src 'none'",
+  "base-uri 'none'",
+  "form-action 'none'"
+].join("; ");
+function mergeFrameAncestors(existing, directive) {
+  if (!existing) return directive;
+  if (/(^|;)\s*frame-ancestors\b/i.test(existing)) return existing;
+  return `${existing}; ${directive}`;
+}
+function applyArtifactSandboxHeaders(c) {
+  c.header("Content-Security-Policy", ARTIFACT_SANDBOX_CSP);
+  c.header("X-Content-Type-Options", "nosniff");
+  c.header("Referrer-Policy", "no-referrer");
+}
+
 // src/auth/routes.ts
 import { Hono as Hono2 } from "hono";
 import { v4 as uuid2 } from "uuid";
@@ -1580,17 +1607,42 @@ authRoutes.get("/teammates", async (c) => {
 
 // src/nests/routes.ts
 import { Hono as Hono3 } from "hono";
-import { streamText } from "hono/streaming";
 
 // src/nodes/service.ts
 import {
-  serializeDocument,
   parseDocument as parseDocument2,
   normalizeStatus,
+  isRejected,
   DocumentNotFoundError
 } from "@promptowl/contextnest-engine";
-import { rename, mkdir, rm } from "fs/promises";
-import { dirname, join as join2, basename } from "path";
+import { rename, mkdir } from "fs/promises";
+import { dirname, join as join2 } from "path";
+
+// src/governance/safe-publish.ts
+import {
+  publishDocument,
+  serializeDocument
+} from "@promptowl/contextnest-engine";
+function serializeNodeSafe(node) {
+  return serializeDocument({
+    ...node,
+    frontmatter: stripUndefinedDeep(node.frontmatter)
+  });
+}
+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/prime-service.ts
 async function isPrimeDocument(nestId, tags, metadata) {
@@ -1615,6 +1667,7 @@ import { join } from "path";
 import {
   detectDrift,
   stageSuggestion,
+  ChainEventLog,
   approveSuggestion,
   rejectSuggestion,
   listSuggestions,
@@ -1697,7 +1750,8 @@ async function scanDocumentForDriftInternal(nestId, documentId, actor) {
   return { meta: result.meta, created: true };
 }
 async function scanNestForDrift(nestId, actor = "system:scanner") {
-  const { storage } = await engineCache.get(nestId);
+  const { storage, invalidateDiscovery } = await engineCache.get(nestId);
+  invalidateDiscovery();
   const docs = await storage.discoverDocuments();
   const results = await Promise.all(
     docs.map((doc) => scanDocumentForDriftInternal(nestId, doc.id, actor))
@@ -1768,6 +1822,68 @@ async function getExternalEditDetail(nestId, documentId, suggestionId) {
     patch: found.patch
   };
 }
+async function recordVerdict(nestId, event) {
+  try {
+    const { storage } = await engineCache.get(nestId);
+    await new ChainEventLog(storage).append(event);
+    return true;
+  } catch (err) {
+    console.error(
+      `[external-edit] failed to record verdict ${event.event_id} for nest ${nestId}:`,
+      err
+    );
+    return false;
+  }
+}
+async function listExternalEditVerdicts(nestId, documentId) {
+  try {
+    const { storage } = await engineCache.get(nestId);
+    const events = await new ChainEventLog(storage).readByDocument(documentId);
+    return events.flatMap((e) => {
+      const meta = e.action_metadata || {};
+      if (typeof meta.suggestion_id !== "string") return [];
+      const reason = meta.rejection_reason;
+      const comment = meta.approval_comment;
+      return [
+        {
+          suggestion_id: meta.suggestion_id,
+          status: typeof reason === "string" ? "rejected" : "approved",
+          actor: e.actor,
+          at: e.timestamp,
+          note: typeof reason === "string" ? reason : typeof comment === "string" ? comment : void 0,
+          source: typeof meta.source === "string" ? meta.source : void 0
+        }
+      ];
+    });
+  } catch (err) {
+    console.error(
+      `[external-edit] failed to read verdicts for ${nestId}/${documentId}:`,
+      err
+    );
+    return [];
+  }
+}
+async function mirrorVersion(input) {
+  const { storage } = await engineCache.get(input.nestId);
+  const node = await storage.readDocument(input.documentId);
+  const { upsertVersion: upsertVersion2, setApprovedVersion: setApprovedVersion2 } = await import("./version-service-EFZGGL3Y.js");
+  await upsertVersion2({
+    nestId: input.nestId,
+    nodeId: input.documentId,
+    version: input.version,
+    content: node.body || "",
+    author: input.actor,
+    status: "published",
+    tags: node.frontmatter.tags || [],
+    changeNote: input.note
+  });
+  await setApprovedVersion2(
+    input.nestId,
+    input.documentId,
+    input.version,
+    input.actor
+  );
+}
 async function approveExternalEdit(input) {
   const { storage } = await engineCache.get(input.nestId);
   let result;
@@ -1789,33 +1905,21 @@ async function approveExternalEdit(input) {
     throw err;
   }
   try {
-    const node = await storage.readDocument(input.documentId);
-    const versionNum = result.versionEntry.version;
-    const tags = node.frontmatter.tags || [];
-    const { createVersion: createVersion2, setApprovedVersion: setApprovedVersion2 } = await import("./version-service-ECYCBVSE.js");
-    await createVersion2({
+    await mirrorVersion({
       nestId: input.nestId,
-      nodeId: input.documentId,
-      version: versionNum,
-      content: node.body || "",
-      author: input.actor,
-      status: "published",
-      tags,
-      changeNote: input.comment || "External edit approved"
+      documentId: input.documentId,
+      version: result.versionEntry.version,
+      actor: input.actor,
+      note: input.comment ? `External edit approved: ${input.comment}` : "External edit approved"
     });
-    await setApprovedVersion2(
-      input.nestId,
-      input.documentId,
-      versionNum,
-      input.actor
-    );
   } catch (err) {
     console.error(
       `[external-edit] failed to mirror approved version into node_versions for ${input.nestId}/${input.documentId}:`,
       err
     );
   }
-  return result;
+  const historyRecorded = await recordVerdict(input.nestId, result.chainEvent);
+  return { ...result, historyRecorded };
 }
 async function rejectExternalEdit(input) {
   const { storage } = await engineCache.get(input.nestId);
@@ -1828,6 +1932,7 @@ async function rejectExternalEdit(input) {
     zone: "default",
     reason: input.reason
   });
+  const historyRecorded = await recordVerdict(input.nestId, result.chainEvent);
   try {
     const approved = await loadChainHead(storage, input.documentId);
     if (approved) {
@@ -1839,7 +1944,7 @@ async function rejectExternalEdit(input) {
       err
     );
   }
-  return result;
+  return { ...result, historyRecorded };
 }
 var scannerTimer = null;
 async function scanAllNests() {
@@ -1881,12 +1986,24 @@ function assertTitleLength(title) {
     );
   }
 }
+function assertTitleSluggable(title) {
+  if (!slugify(title)) {
+    throw new ValidationError(
+      "the document id is built from the title using a-z and 0-9, so the title needs at least one of those"
+    );
+  }
+}
 var slugify = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 function isIdUnderFolder(id, folder) {
   return id.startsWith(`nodes/${folder}/`) || id.startsWith(`${folder}/`);
 }
 function folderToSegments(folder) {
   const segments = folder.split("/").map(slugify).filter(Boolean);
+  if (folder.trim() && segments.length === 0) {
+    throw new ValidationError(
+      "the folder path is built from the name using a-z and 0-9, so the name needs at least one of those"
+    );
+  }
   if (segments[0] === "nodes") segments.shift();
   if (segments.length > 8) {
     throw new ValidationError("folder may nest at most 8 levels deep");
@@ -1898,7 +2015,6 @@ function folderToSegments(folder) {
   }
   return segments;
 }
-var stripUndefined = (o) => Object.fromEntries(Object.entries(o).filter(([, v]) => v !== void 0));
 async function departmentTagFor(userEmail) {
   if (!config.OIDC_DEPARTMENT_TAGGING) return null;
   try {
@@ -1915,6 +2031,12 @@ async function departmentTagFor(userEmail) {
 }
 function toSafeError(err, context, message) {
   if (err instanceof AppError) return err;
+  if (err?.code === "REJECTED_DOCUMENT") {
+    console.error(`${context}:`, err);
+    return new ConflictError(
+      "This document is rejected. Change its status before saving."
+    );
+  }
   console.error(`${context}:`, err);
   return new AppError(500, message);
 }
@@ -2005,28 +2127,86 @@ async function resolveAuthorship(nestId, nodes) {
   }
   return result;
 }
-async function listNodesForCaller(nestId, userId, filters = {}) {
-  const { storage, versions: versionManager } = await engineCache.get(nestId);
-  let documents = await storage.discoverDocuments();
-  if (filters.type) {
-    const wanted = new Set(
-      Array.isArray(filters.type) ? filters.type : [filters.type]
+async function getNodeForCaller(nestId, selector, userId, userEmail, opts = {}) {
+  if (selector.id && !await canReadNode(nestId, selector.id, userId, userEmail)) {
+    throw new ForbiddenError(
+      "Access denied \u2014 no steward assignment for this node"
     );
-    documents = documents.filter((n) => wanted.has(n.frontmatter.type));
   }
-  if (filters.tag) {
-    const tag = normalizeTag2(filters.tag);
-    documents = documents.filter(
-      (n) => (n.frontmatter.tags || []).includes(tag)
+  let got;
+  try {
+    got = await engineApi.run(
+      "context_get",
+      {
+        ...selector,
+        include_raw: true,
+        // A retired node stays readable here: its stewards decide whether to
+        // revive it, and they cannot do that if the read refuses.
+        allow_rejected: true,
+        ...opts.verifyChecksum ? { verify_checksum: true } : {}
+      },
+      await opContext(nestId, userEmail)
     );
+  } catch (err) {
+    if (err?.code !== "DOCUMENT_NOT_FOUND") {
+      console.error(`getNodeForCaller failed (${nestId}/${selector.id ?? selector.title})`, err);
+    }
+    throw new NotFoundError(`Node not found: ${selector.id ?? selector.title}`);
   }
-  const userEmail = await resolveCallerEmail(userId);
-  let accessible = await filterAccessible(nestId, userId, userEmail, documents);
-  if (await resolveNestPermission(nestId, userId) === "none" && !await isStewardshipEnabled(nestId)) {
-    const grants = await listUserGrants(nestId, userId);
-    accessible = grants.length ? documents.filter((d) => grantCoversNode(grants, d.id)) : accessible;
+  if (!selector.id && !await canReadNode(nestId, got.id, userId, userEmail)) {
+    throw new ForbiddenError(
+      "Access denied \u2014 no steward assignment for this node"
+    );
   }
+  return {
+    id: got.id,
+    filePath: "",
+    rawContent: got.raw ?? "",
+    frontmatter: got.frontmatter,
+    body: got.body,
+    ...got.pendingChange ? { pendingChange: got.pendingChange } : {}
+  };
+}
+async function listNodesForCaller(nestId, userId, filters = {}) {
+  const { versions: versionManager } = await engineCache.get(nestId);
+  const userEmail = await resolveCallerEmail(userId);
+  const { documents } = await engineApi.run(
+    "context_list",
+    {
+      ...filters.type ? { type: filters.type } : {},
+      ...filters.tag ? { tag: filters.tag } : {},
+      ...filters.status ? { status: filters.status } : {},
+      // Unlike the CLI and mcp-server, a retired node stays in this listing:
+      // here it is an unpublished document its stewards may still need to act
+      // on, not one removed from retrieval. An imported vault carrying
+      // `status: rejected` registers exactly that way.
+      include_retired: true,
+      full: true
+    },
+    await opContext(nestId, userEmail)
+  );
+  const nodes = documents.map((d) => ({
+    id: d.id,
+    filePath: "",
+    rawContent: "",
+    frontmatter: d.frontmatter,
+    body: d.body
+  }));
   const publicReader = await isPublicReader(nestId, userId);
+  const approvedOnly = publicReader || filters.approvedOnly === true;
+  const approvedVersions = approvedOnly ? await getApprovedVersions(nestId) : null;
+  let accessible = await filterAccessible(
+    nestId,
+    userId,
+    userEmail,
+    nodes,
+    approvedVersions ?? void 0
+  );
+  const myGrants = await listUserGrants(nestId, userId);
+  if (approvedVersions && !publicReader) {
+    accessible = accessible.filter((d) => approvedVersions.has(d.id));
+  }
+  if (filters.limit) accessible = accessible.slice(0, filters.limit);
   const authorship = publicReader ? null : await resolveAuthorship(
     nestId,
     accessible.map((d) => ({
@@ -2042,8 +2222,11 @@ async function listNodesForCaller(nestId, userId, filters = {}) {
         r.author = people.author;
         r.collaborators = people.collaborators;
       }
-      if (publicReader) {
-        const approved = await getApprovedVersion(nestId, doc.id);
+      if (myGrants.length) {
+        r.myGrant = grantRoleForNode(myGrants, doc.id);
+      }
+      if (approvedVersions) {
+        const approved = approvedVersions.get(doc.id);
         if (approved != null) {
           try {
             const raw = await versionManager.reconstructVersion(
@@ -2080,7 +2263,7 @@ async function listNodesForCaller(nestId, userId, filters = {}) {
       return r;
     })
   );
-  return filters.limit ? enriched.slice(0, filters.limit) : enriched;
+  return enriched;
 }
 async function listNodesForCallerByEmail(nestId, userEmail, filters = {}) {
   return listNodesForCaller(nestId, await userIdFromEmail(userEmail), filters);
@@ -2109,13 +2292,13 @@ async function autoPublishReason(nestId, userEmail, doc) {
 async function createNode(nestId, input, userEmail) {
   const { storage, versions: versionManager } = await engineCache.get(nestId);
   assertTitleLength(input.title);
+  if (!input.id) assertTitleSluggable(input.title);
   const slug = slugify(input.title).slice(0, 100).replace(/-+$/, "");
   let id = input.id;
   if (!id) {
     const folderSegments = folderToSegments(input.folder ?? "");
     id = folderSegments.length > 0 ? `nodes/${folderSegments.join("/")}/${slug}` : `nodes/${slug}`;
   }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
   const tags = (input.tags || []).map(normalizeTag2);
   const requestedType = input.type || "document";
   if (requestedType === "artifact" && !config.TYPE_ARTIFACT_ENABLED) {
@@ -2172,33 +2355,62 @@ async function createNode(nestId, input, userEmail) {
       tags,
       metadata
     });
-    const autoPublish = publishReason !== null;
-    const initialStatus = autoPublish ? "published" : "draft";
-    const initialVersion = autoPublish ? 0 : 1;
-    let node = {
-      id,
-      filePath: "",
-      frontmatter: {
-        title: input.title,
-        type: requestedType,
-        tags,
-        status: input.status || initialStatus,
-        version: initialVersion,
-        created_at: now,
-        updated_at: now,
-        metadata
-      },
-      body: input.content,
-      rawContent: ""
-    };
-    await storage.writeDocument(id, serializeDocument(node));
+    const publishNote = publishReason === null ? void 0 : `Auto-published on create (${publishReason})`;
+    let published = publishReason !== null;
+    try {
+      await engineApi.run(
+        "context_create",
+        {
+          id,
+          title: input.title,
+          content: input.content,
+          type: requestedType,
+          // A skill node is invalid without a skill block, and this surface has
+          // no field for one — default the trigger from the title, same as the
+          // CLI and mcp-server do.
+          ...requestedType === "skill" ? { trigger: `when asked to ${input.title.toLowerCase()}` } : {},
+          ...tags.length ? { tags } : {},
+          ...input.status ? { status: input.status } : {},
+          metadata,
+          publish: published,
+          ...publishNote ? { note: publishNote } : {}
+        },
+        await opContext(nestId, userEmail)
+      );
+    } catch (err) {
+      let onDisk = true;
+      try {
+        await storage.readDocument(id);
+      } catch {
+        onDisk = false;
+      }
+      if (!onDisk) throw err;
+      console.error("publishDocument failed (node create auto-publish)", err);
+      published = false;
+    }
+    const node = await storage.readDocument(id);
     await syncNodeTags(nestId, id, tags);
     let savedVersion = 1;
-    if (publishReason === null) {
-      try {
-        await versionManager.createVersion(node, userEmail);
-      } catch (err) {
-        console.error("VersionManager.createVersion failed (node create)", err);
+    if (published) {
+      savedVersion = node.frontmatter.version || 1;
+      await createVersion({
+        nestId,
+        nodeId: id,
+        version: savedVersion,
+        content: node.body || "",
+        author: userEmail,
+        status: "published",
+        tags,
+        changeNote: publishNote
+      });
+      await setApprovedVersion(nestId, id, savedVersion, userEmail);
+    } else {
+      if (publishReason === null) {
+        try {
+          await versionManager.createVersion(node, userEmail);
+        } catch (err) {
+          console.error("VersionManager.createVersion failed (node create)", err);
+        }
       }
       await createVersion({
         nestId,
@@ -2209,170 +2421,100 @@ async function createNode(nestId, input, userEmail) {
         status: "draft",
         tags
       });
-    } else {
-      const publishNote = `Auto-published on create (${publishReason})`;
-      try {
-        const result = await safePublishDocument(storage, id, {
-          editedBy: userEmail,
-          note: publishNote
-        });
-        savedVersion = result.node.frontmatter.version || 1;
-        await createVersion({
-          nestId,
-          nodeId: id,
-          version: savedVersion,
-          content: result.node.body || "",
-          author: userEmail,
-          status: "published",
-          tags,
-          changeNote: publishNote
-        });
-        await setApprovedVersion(nestId, id, savedVersion, userEmail);
-        node = result.node;
-      } catch (err) {
-        console.error("publishDocument failed (node create auto-publish)", err);
-        await createVersion({
-          nestId,
-          nodeId: id,
-          version: 1,
-          content: input.content,
-          author: userEmail,
-          status: "draft",
-          tags
-        });
-      }
     }
     await trackEvent("node.create", { nestId, nodeId: id });
     return { node, version: savedVersion };
   });
 }
-function explicitFrontmatterStatus(raw) {
-  const fm = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  if (!fm) return null;
-  const m = fm[1].match(/^status:[ \t]*["']?([A-Za-z_-]+)["']?[ \t]*$/m);
-  return m ? normalizeStatus(m[1]) : null;
-}
-async function resetImportedDocForPublish(storage, nestId, nodeId) {
-  const versionsDir = join2(
-    resolveNestPath(nestId),
-    dirname(nodeId),
-    ".versions",
-    basename(nodeId)
-  );
-  await rm(versionsDir, { recursive: true, force: true });
-  const node = await storage.readDocument(nodeId);
-  const fm = { ...node.frontmatter };
-  delete fm.version;
-  delete fm.checksum;
-  await storage.writeDocument(nodeId, serializeNodeSafe({ ...node, frontmatter: fm }));
-}
-async function registerImportedDocuments(nestId, userEmail, onProgress) {
-  const { storage } = await engineCache.get(nestId);
-  let docs;
+async function stageImportedFiles(nestId, files, userEmail) {
+  const carried = files.filter(
+    (f) => !String(f?.path || "").split(/[\\/]/).includes("_suggestions")
+  );
+  if (!carried.length) return { written: 0, rejected: [] };
+  const result = await engineApi.run(
+    "context_import",
+    { files: carried, publish: false },
+    await opContext(nestId, userEmail)
+  );
+  const rejected = (result.failed ?? []).map((f) => f.id ?? "(unnamed)");
+  if (rejected.length) {
+    console.warn(
+      `[import] ${rejected.length} file(s) rejected:`,
+      (result.failed ?? []).map((f) => `${f.id}: ${f.error}`).join(", ")
+    );
+  }
+  return { written: result.written ?? 0, rejected };
+}
+async function alignOnDiskStatus(nestId, documentId, status) {
   try {
-    docs = await storage.discoverDocuments();
+    const { storage } = await engineCache.get(nestId);
+    const node = await storage.readDocument(documentId);
+    if (node.frontmatter.status === status) return;
+    await storage.writeDocument(
+      documentId,
+      serializeNodeSafe({
+        ...node,
+        frontmatter: { ...node.frontmatter, status }
+      })
+    );
   } catch (err) {
-    console.error("registerImportedDocuments: discovery failed", nestId, err);
-    return 0;
+    console.warn(
+      `[import] could not align on-disk status for ${nestId}/${documentId}:`,
+      err
+    );
   }
+}
+async function registerImportedDocuments(nestId, userEmail) {
   const startedAt = Date.now();
-  console.log(`[import] register: discovered=${docs.length} nest=${nestId}`);
-  await onProgress?.(0, docs.length);
-  let registered = 0;
-  let alreadyTracked = 0;
-  let publishFailed = 0;
-  let publishRecovered = 0;
-  let keptUnpublished = 0;
-  let processed = 0;
-  for (let doc of docs) {
-    const nodeId = doc.id;
-    await onProgress?.(++processed, docs.length);
-    if (await getCurrentVersion(nestId, nodeId) > 0) {
-      alreadyTracked++;
-      continue;
-    }
-    const title = doc.frontmatter?.title ?? (nodeId.split("/").pop() || nodeId);
-    doc = { ...doc, frontmatter: { ...doc.frontmatter, title, author: userEmail } };
-    try {
-      await storage.writeDocument(nodeId, serializeNodeSafe(doc));
-    } catch (err) {
-      console.error("import: failed to persist import metadata", nodeId, err);
-    }
-    const rawTags = Array.isArray(doc.frontmatter?.tags) ? doc.frontmatter.tags : [];
-    const tags = rawTags.map((t) => normalizeTag2(String(t)));
-    const fmVersion = Number(doc.frontmatter?.version);
-    let version = Number.isInteger(fmVersion) && fmVersion > 0 ? fmVersion : 1;
-    let content = doc.body || "";
-    const status = explicitFrontmatterStatus(doc.rawContent);
-    if (status && status !== "published" && status !== "approved") {
-      await createVersion({
-        nestId,
-        nodeId,
-        version,
-        content,
-        author: userEmail,
-        status: "draft",
-        changeNote: "Imported from existing folder (kept unpublished)",
-        tags
-      });
-      await syncNodeTags(nestId, nodeId, tags);
-      keptUnpublished++;
-      registered++;
-      continue;
-    }
-    let published = false;
-    try {
-      const result = await safePublishDocument(storage, nodeId, {
-        editedBy: userEmail,
-        note: "Imported from existing folder"
-      });
-      version = result.node.frontmatter.version || version;
-      content = result.node.body || content;
-      published = true;
-    } catch (err) {
-      console.warn(
-        `[import] publish retry needed for ${nodeId}: ${err?.message ?? err}`
-      );
-      try {
-        await resetImportedDocForPublish(storage, nestId, nodeId);
-        const result = await safePublishDocument(storage, nodeId, {
-          editedBy: userEmail,
-          note: "Imported from existing folder (reset chain)"
-        });
-        version = result.node.frontmatter.version || 1;
-        content = result.node.body || content;
-        published = true;
-        publishRecovered++;
-      } catch (err2) {
-        publishFailed++;
-        console.error(
-          "reset+republish failed (import register)",
-          nodeId,
-          err2
-        );
-      }
-    }
+  const tracked = await getTrackedNodeIds(nestId);
+  (await engineCache.get(nestId)).invalidateDiscovery();
+  let result;
+  try {
+    result = await engineApi.run(
+      "context_import",
+      { discover: true, author: userEmail, exclude_ids: [...tracked] },
+      await opContext(nestId, userEmail)
+    );
+  } catch (err) {
+    console.error("[import] register failed", nestId, err);
+    throw new Error(
+      `Failed to import documents: ${err?.message ?? String(err)}`
+    );
+  }
+  const docs = result.documents ?? [];
+  const engineMs = Date.now() - startedAt;
+  const dbStartedAt = Date.now();
+  for (const d of docs) {
+    const tags = d.tags.map((t) => normalizeTag2(String(t)));
     await createVersion({
       nestId,
-      nodeId,
-      version,
-      content,
+      nodeId: d.id,
+      version: d.version,
+      content: d.content,
       author: userEmail,
-      status: published ? "published" : "draft",
-      changeNote: "Imported from existing folder",
+      status: d.status,
+      changeNote: d.status === "published" ? "Imported from existing folder" : "Imported from existing folder \u2014 could not be published, kept as a draft",
       tags
     });
-    if (published) {
-      await setApprovedVersion(nestId, nodeId, version, userEmail);
+    if (d.status === "published") {
+      await setApprovedVersion(nestId, d.id, d.version, userEmail);
+    } else {
+      await alignOnDiskStatus(nestId, d.id, d.status);
     }
-    await syncNodeTags(nestId, nodeId, tags);
-    registered++;
+    await syncNodeTags(nestId, d.id, tags);
   }
+  const published = docs.filter((d) => d.status === "published").length;
   console.log(
-    `[import] register done: registered=${registered} alreadyTracked=${alreadyTracked} keptUnpublished=${keptUnpublished} publishRecovered=${publishRecovered} publishFailed=${publishFailed} tookMs=${Date.now() - startedAt}`
+    `[import] register done: registered=${docs.length} published=${published} kept=${docs.length - published} failed=${result.failed.length} alreadyTracked=${tracked.size} engineMs=${engineMs} dbMs=${Date.now() - dbStartedAt}`
   );
-  await trackEvent("nest.import.documents", { nestId, registered });
-  return registered;
+  if (result.failed.length) {
+    console.warn(
+      "[import] documents that would not publish:",
+      result.failed.map((f) => `${f.id}: ${f.error}`).join(", ")
+    );
+  }
+  await trackEvent("nest.import.documents", { nestId, registered: docs.length });
+  return docs.length;
 }
 async function updateNode(nestId, nodeId, patch, userEmail) {
   return withNodeWriteLock(nodeWriteKey(nestId, nodeId), async () => {
@@ -2386,33 +2528,43 @@ async function updateNode(nestId, nodeId, patch, userEmail) {
       } catch {
         throw new NotFoundError(`Node not found: ${nodeId}`);
       }
+      const opInput = {};
       if (patch.content !== void 0) {
         node = { ...node, body: patch.content };
+        opInput.content = patch.content;
       }
       if (patch.append) {
         node = { ...node, body: (node.body || "") + "\n\n" + patch.append };
+        opInput.append = "\n" + patch.append;
       }
       if (patch.tags) {
-        const newTags = patch.tags.map(normalizeTag2);
-        const merged = [
-          .../* @__PURE__ */ new Set([...node.frontmatter.tags || [], ...newTags])
-        ];
-        node = { ...node, frontmatter: { ...node.frontmatter, tags: merged } };
+        const nextTags = [...new Set(patch.tags.map(normalizeTag2))];
+        node = { ...node, frontmatter: { ...node.frontmatter, tags: nextTags } };
+        opInput.tags = nextTags;
       }
       if (patch.status) {
         node = {
           ...node,
           frontmatter: { ...node.frontmatter, status: patch.status }
         };
+        opInput.status = normalizeStatus(patch.status);
+      } else if (isRejected(node)) {
+        node = {
+          ...node,
+          frontmatter: { ...node.frontmatter, status: "draft" }
+        };
+        opInput.status = "draft";
       }
       if (patch.title) {
         if (patch.title !== node.frontmatter.title) {
           assertTitleLength(patch.title);
+          assertTitleSluggable(patch.title);
         }
         node = {
           ...node,
           frontmatter: { ...node.frontmatter, title: patch.title }
         };
+        opInput.title = patch.title;
       }
       if (patch.schedule !== void 0) {
         if (!isRunnableType(node.frontmatter.type)) {
@@ -2426,6 +2578,10 @@ async function updateNode(nestId, nodeId, patch, userEmail) {
         if (patch.schedule === "") delete metadata.schedule;
         else metadata.schedule = patch.schedule;
         node = { ...node, frontmatter: { ...node.frontmatter, metadata } };
+        opInput.metadata = {
+          ...opInput.metadata,
+          schedule: patch.schedule === "" ? null : patch.schedule
+        };
       }
       if (patch.prime !== void 0) {
         await assertMayFlagPrime(nestId, userEmail);
@@ -2433,6 +2589,7 @@ async function updateNode(nestId, nodeId, patch, userEmail) {
         if (patch.prime === null) delete metadata.prime;
         else metadata.prime = patch.prime;
         node = { ...node, frontmatter: { ...node.frontmatter, metadata } };
+        opInput.metadata = { ...opInput.metadata, prime: patch.prime };
       }
       const hasStewards = await isStewardshipEnabled(nestId);
       const currentTags = node.frontmatter.tags || [];
@@ -2451,19 +2608,12 @@ async function updateNode(nestId, nodeId, patch, userEmail) {
       if (publishReason === null || isAuthorEditingOwnReview) {
         const currentVersion = await getCurrentVersion(nestId, nodeId);
         const newVersion = await versionManager.nextVersion(nodeId, currentVersion);
-        node = {
-          ...node,
-          frontmatter: {
-            ...node.frontmatter,
-            version: newVersion,
-            updated_at: (/* @__PURE__ */ new Date()).toISOString(),
-            // Drop stale published-state checksum so the next verified read
-            // doesn't flag this write as external drift.
-            checksum: void 0
-          }
-        };
-        node = { ...node, frontmatter: stripUndefined(node.frontmatter) };
-        await storage.writeDocument(nodeId, serializeDocument(node));
+        await engineApi.run(
+          "context_update",
+          { id: nodeId, ...opInput, publish: false, version: newVersion },
+          await opContext(nestId, userEmail)
+        );
+        node = await storage.readDocument(nodeId);
         await syncNodeTags(nestId, nodeId, currentTags);
         try {
           await versionManager.createVersion(node, userEmail, {
@@ -2491,26 +2641,15 @@ async function updateNode(nestId, nodeId, patch, userEmail) {
         }
         responseVersion = newVersion;
       } else {
-        node = {
-          ...node,
-          frontmatter: {
-            ...node.frontmatter,
-            updated_at: (/* @__PURE__ */ new Date()).toISOString(),
-            checksum: void 0
-          }
-        };
-        node = { ...node, frontmatter: stripUndefined(node.frontmatter) };
-        await storage.writeDocument(nodeId, serializeDocument(node));
-        await syncNodeTags(nestId, nodeId, currentTags);
-        let publishedVersion = (node.frontmatter.version || 0) + 1;
         const publishNote = patch.changeNote || `Auto-published on edit (${publishReason})`;
+        let publishedVersion;
         try {
-          const result = await safePublishDocument(storage, nodeId, {
-            editedBy: userEmail,
-            note: publishNote
-          });
-          publishedVersion = result.node.frontmatter.version || publishedVersion;
-          node = result.node;
+          const result = await engineApi.run(
+            "context_update",
+            { id: nodeId, ...opInput, publish: true, note: publishNote },
+            await opContext(nestId, userEmail)
+          );
+          publishedVersion = result.version;
         } catch (err) {
           console.error(
             "publishDocument failed (node patch auto-publish)",
@@ -2518,6 +2657,8 @@ async function updateNode(nestId, nodeId, patch, userEmail) {
           );
           throw err;
         }
+        node = await storage.readDocument(nodeId);
+        await syncNodeTags(nestId, nodeId, currentTags);
         await upsertVersion({
           nestId,
           nodeId,
@@ -2685,14 +2826,22 @@ async function deleteNode(nestId, nodeId, userEmail) {
   const { storage } = await engineCache.get(nestId);
   await assertNotReviewLocked(nestId, nodeId, userEmail, "deleting");
   try {
-    await storage.deleteDocument(nodeId);
+    await engineApi.run(
+      "context_delete",
+      { id: nodeId },
+      await opContext(nestId, userEmail)
+    );
   } catch {
     throw new NotFoundError(`Node not found: ${nodeId}`);
   }
   await removeNodeFromTagIndex(nestId, nodeId);
   const derivedId = derivedIdOf(nodeId);
   try {
-    await storage.deleteDocument(derivedId);
+    await engineApi.run(
+      "context_delete",
+      { id: derivedId },
+      await opContext(nestId, userEmail)
+    );
     await removeNodeFromTagIndex(nestId, derivedId);
   } catch {
   }
@@ -2738,8 +2887,9 @@ async function deleteFolder(nestId, folder, userEmail) {
 }
 
 // src/nests/unsynced-service.ts
-import { readdirSync, readFileSync, rmSync, statSync } from "fs";
+import { readdirSync, readFileSync, statSync } from "fs";
 import { join as join3, relative, resolve } from "path";
+import { rm } from "fs/promises";
 var RESERVED = /* @__PURE__ */ new Set(["nests"]);
 function isNestStorageRoot(absPath) {
   return resolve(absPath) === resolve(nestStorageRoot());
@@ -2907,23 +3057,31 @@ async function syncUnsyncedFolder(userId, folderName, callerEmail) {
       `[unsynced] name "${baseName}" already in use, using "${nestName2}" instead`
     );
   }
-  const nest = await importNest(userId, nestName2, files);
+  const nest = await importNest(userId, nestName2);
   console.log(
     `[unsynced] nest created id=${nest.id} name="${nest.name}" from folder="${folderName}"`
   );
-  const documents = await registerImportedDocuments(nest.id, callerEmail);
+  let documents;
+  try {
+    await stageImportedFiles(nest.id, files, callerEmail);
+    documents = await registerImportedDocuments(nest.id, callerEmail);
+  } catch (err) {
+    await deleteNest(nest.id).catch(() => {
+    });
+    throw err;
+  }
   console.log(
     `[unsynced] registered ${documents} document(s) for nest ${nest.id}`
   );
   try {
-    rmSync(src, { recursive: true, force: true });
+    await rm(src, { recursive: true, force: true });
     console.log(`[unsynced] removed source folder ${src}`);
   } catch (err) {
     console.error("[unsynced] failed to remove source folder", src, err);
   }
   return { nest, documents };
 }
-function deleteUnsyncedFolder(folderName) {
+async function deleteUnsyncedFolder(folderName) {
   console.log(`[unsynced] delete requested folder="${folderName}"`);
   assertSafeFolderName(folderName);
   const src = join3(config.DATA_ROOT, folderName);
@@ -2939,21 +3097,27 @@ function deleteUnsyncedFolder(folderName) {
   if (!stat.isDirectory()) {
     throw new ValidationError(`Not a directory: ${folderName}`);
   }
-  rmSync(src, { recursive: true, force: true });
+  await rm(src, { recursive: true, force: true });
   console.log(`[unsynced] deleted folder ${src}`);
 }
 
 // src/nests/routes.ts
-async function effectivePermission(nestId, userId) {
-  if (config.AUTH_MODE === "open") {
-    const db = getDb();
-    const nest = await db.get(
-      "SELECT user_id FROM nests WHERE id = ?",
-      [nestId]
-    );
-    if (nest && nest.user_id === ANON_USER_ID) return "owner";
+async function effectiveAccess(nestId, userId) {
+  const access = await resolveNestAccess(nestId, userId);
+  if (config.AUTH_MODE === "open" && access.ownerId === ANON_USER_ID) {
+    return { permission: "owner", access };
+  }
+  const permission = access.permission;
+  if (permission === "none" && access.hasGrant) {
+    return { permission: "read", access };
   }
-  return resolveNestPermission(nestId, userId);
+  return { permission, access };
+}
+async function effectivePermission(nestId, userId) {
+  return (await effectiveAccess(nestId, userId)).permission;
+}
+function isGrantOnly(access) {
+  return access.permission === "none" && access.hasGrant;
 }
 var nestRoutes = new Hono3();
 nestRoutes.get("/", async (c) => {
@@ -2964,8 +3128,31 @@ nestRoutes.get("/", async (c) => {
   const db = getDb();
   const ownerEmailSql = "SELECT email FROM users WHERE id = ?";
   const callerEmail = await resolveCallerEmail(userId);
+  const myGrantRows = await db.all(
+    "SELECT nest_id, target FROM grants WHERE user_id = ?",
+    [userId]
+  );
+  const grantTargetsByNest = /* @__PURE__ */ new Map();
+  for (const r of myGrantRows) {
+    const arr = grantTargetsByNest.get(r.nest_id) ?? [];
+    arr.push({ target: r.target });
+    grantTargetsByNest.set(r.nest_id, arr);
+  }
   const annotate = async (n) => {
-    const permission = await effectivePermission(n.id, userId);
+    const { permission, access } = await effectiveAccess(n.id, userId);
+    if (permission !== "owner" && // open-mode commons promotion outranks a grant
+    isGrantOnly(access)) {
+      const owner_email2 = n.user_id === ANON_USER_ID ? null : (await db.get(ownerEmailSql, [n.user_id]))?.email ?? null;
+      return {
+        ...n,
+        permission: "read",
+        is_owner: false,
+        owner_email: owner_email2,
+        roles: ["viewer"],
+        grant_only: true,
+        stewardship_enabled: !!n.stewardship_enabled
+      };
+    }
     const is_owner = permission === "owner";
     const needOwnerEmail = !is_owner && n.user_id !== ANON_USER_ID;
     const [roles, owner_email] = await Promise.all([
@@ -2980,6 +3167,7 @@ nestRoutes.get("/", async (c) => {
       is_owner,
       owner_email,
       roles,
+      grant_only: false,
       stewardship_enabled: !!n.stewardship_enabled
     };
   };
@@ -3023,14 +3211,38 @@ nestRoutes.get("/", async (c) => {
     if (arr.length < 8) arr.push(r.email);
     collabEmailsByNest.set(r.nest_id, arr);
   }
-  const withMeta = out.map((n) => ({
-    ...n,
-    document_count: docByNest.get(n.id) ?? 0,
-    collaborator_count: collabByNest.get(n.id) ?? 0,
-    steward_count: stewardByNest.get(n.id) ?? 0,
-    steward_emails: stewardEmailsByNest.get(n.id) ?? [],
-    collaborator_emails: collabEmailsByNest.get(n.id) ?? []
-  }));
+  const grantOnlyIds = out.filter((n) => n.grant_only).map((n) => n.id);
+  const grantedDocsByNest = /* @__PURE__ */ new Map();
+  if (grantOnlyIds.length) {
+    const rows = await db.all(
+      `SELECT DISTINCT nest_id, node_id FROM node_versions
+        WHERE nest_id IN (${grantOnlyIds.map(() => "?").join(",")})`,
+      grantOnlyIds
+    );
+    for (const r of rows) {
+      const targets = grantTargetsByNest.get(r.nest_id) ?? [];
+      if (grantCoversNode(targets, r.node_id)) {
+        grantedDocsByNest.set(r.nest_id, (grantedDocsByNest.get(r.nest_id) ?? 0) + 1);
+      }
+    }
+  }
+  const withMeta = out.map(
+    (n) => n.grant_only ? {
+      ...n,
+      document_count: grantedDocsByNest.get(n.id) ?? 0,
+      collaborator_count: 0,
+      steward_count: 0,
+      steward_emails: [],
+      collaborator_emails: []
+    } : {
+      ...n,
+      document_count: docByNest.get(n.id) ?? 0,
+      collaborator_count: collabByNest.get(n.id) ?? 0,
+      steward_count: stewardByNest.get(n.id) ?? 0,
+      steward_emails: stewardEmailsByNest.get(n.id) ?? [],
+      collaborator_emails: collabEmailsByNest.get(n.id) ?? []
+    }
+  );
   return c.json({ nests: withMeta });
 });
 nestRoutes.post("/", async (c) => {
@@ -3046,42 +3258,50 @@ nestRoutes.post("/:nestId", async (c) => {
     throw new NotFoundError("Not found");
   }
   const body = await c.req.json();
+  const files = Array.isArray(body.files) ? body.files : [];
+  const userId = c.get("userId");
+  if (body.nestId) {
+    const target = body.nestId;
+    const nest2 = await getNest(target);
+    if (!nest2 || !nest2.is_imported || await effectivePermission(target, userId) !== "owner") {
+      throw new NotFoundError("Nest not found");
+    }
+    const email2 = await resolveCallerEmail(userId);
+    if (body.finalize) {
+      return c.json({ nest: nest2, documents: await registerImportedDocuments(target, email2) });
+    }
+    const registered = await getDb().get(
+      "SELECT COUNT(*) AS c FROM node_versions WHERE nest_id = ?",
+      [target]
+    );
+    if (Number(registered?.c ?? 0) > 0) {
+      throw new ValidationError(
+        "This nest has already been imported. Start a new import instead of adding files to a finished one."
+      );
+    }
+    console.log(`[import] chunk: nest=${target} files=${files.length}`);
+    return c.json(await stageImportedFiles(target, files, email2));
+  }
   if (!body.name) {
     throw new ValidationError("name is required");
   }
-  const files = Array.isArray(body.files) ? body.files : [];
-  const userId = c.get("userId");
   console.log(
-    `[import] request: name=${JSON.stringify(body.name)} files=${files.length}`
+    `[import] request: name=${JSON.stringify(body.name)} files=${files.length}` + (body.partial ? " (first chunk)" : "")
   );
-  if (c.req.query("stream") === "1") {
-    const name = body.name;
-    return streamText(c, async (stream) => {
-      try {
-        await stream.writeln(JSON.stringify({ phase: "write" }));
-        const nest2 = await importNest(userId, name, files);
-        const email = await resolveCallerEmail(userId);
-        const documents2 = await registerImportedDocuments(
-          nest2.id,
-          email,
-          async (done, total) => {
-            await stream.writeln(JSON.stringify({ phase: "register", done, total }));
-          }
-        );
-        await stream.writeln(JSON.stringify({ complete: true, nest: nest2, documents: documents2 }));
-      } catch (err) {
-        await stream.writeln(
-          JSON.stringify({ error: err?.message || "Import failed" })
-        );
-      }
+  const email = await resolveCallerEmail(userId);
+  const nest = await importNest(userId, body.name);
+  try {
+    const { rejected } = await stageImportedFiles(nest.id, files, email);
+    if (body.partial) {
+      return c.json({ nest, rejected }, 201);
+    }
+    const documents = await registerImportedDocuments(nest.id, email);
+    return c.json({ nest, documents, rejected }, 201);
+  } catch (err) {
+    await deleteNest(nest.id).catch(() => {
     });
+    throw err;
   }
-  const nest = await importNest(userId, body.name, files);
-  const documents = await registerImportedDocuments(
-    nest.id,
-    await resolveCallerEmail(userId)
-  );
-  return c.json({ nest, documents }, 201);
 });
 async function handleUnsyncedList(c) {
   const userId = c.get("userId");
@@ -3121,14 +3341,14 @@ nestRoutes.delete("/:nestId/sync", async (c) => {
   if (!body?.name) {
     throw new ValidationError("name is required");
   }
-  deleteUnsyncedFolder(body.name);
+  await deleteUnsyncedFolder(body.name);
   return c.json({ ok: true });
 });
 nestRoutes.get("/:nestId", async (c) => {
   const nestId = c.req.param("nestId");
   if (nestId === "unsynced") return handleUnsyncedList(c);
   const userId = c.get("userId");
-  const permission = await effectivePermission(nestId, userId);
+  const { permission, access } = await effectiveAccess(nestId, userId);
   if (permission === "none") {
     throw new NotFoundError("Nest not found");
   }
@@ -3138,8 +3358,15 @@ nestRoutes.get("/:nestId", async (c) => {
     roles = ["owner", ...roles];
   }
   const myStewards = await getStewardsForUser(nestId, email);
+  const grant_only = roles.length === 0 && isGrantOnly(access);
   const nest = await getNest(nestId);
-  return c.json({ nest, permission, roles, myStewards });
+  return c.json({
+    nest,
+    permission,
+    roles: grant_only ? ["viewer"] : roles,
+    myStewards,
+    grant_only
+  });
 });
 nestRoutes.patch("/:nestId", async (c) => {
   const nestId = c.req.param("nestId");
@@ -3838,27 +4065,62 @@ teamRoutes.delete("/:teamId/members/:userId", async (c) => {
   return c.json({ team });
 });
 
+// src/nodes/search.ts
+async function discoverForSearch(storage) {
+  return storage.discoverDocuments({ includeRetired: true });
+}
+function titleScore(title, query) {
+  const t = (title || "").toLowerCase();
+  const q = query.trim().toLowerCase();
+  if (!q) return 0;
+  if (t === q) return 4;
+  let midWord = false;
+  for (let i = t.indexOf(q); i !== -1; i = t.indexOf(q, i + 1)) {
+    if (i === 0) return 3;
+    if (!/[a-z0-9]/.test(t[i - 1])) return 2;
+    midWord = true;
+  }
+  if (midWord) return 1;
+  const terms = q.split(/\s+/).filter(Boolean);
+  if (terms.length > 1 && terms.every((term) => t.includes(term))) return 1;
+  return 0;
+}
+function matchDocuments(documents, query) {
+  const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+  if (terms.length === 0) return [];
+  return documents.filter((node) => {
+    const haystack = [
+      node.frontmatter.title,
+      node.body || "",
+      node.frontmatter.type || "",
+      ...node.frontmatter.tags || []
+    ].join(" ").toLowerCase();
+    return terms.every((term) => haystack.includes(term));
+  }).sort(
+    (a, b) => titleScore(b.frontmatter.title, query) - titleScore(a.frontmatter.title, query)
+  );
+}
+function bodySnippet(body, query) {
+  const flat = body.replace(/\s+/g, " ").trim();
+  const terms = (query || "").toLowerCase().split(/\s+/).filter(Boolean);
+  const at = terms.map((t) => flat.toLowerCase().indexOf(t)).filter((i) => i >= 0).sort((a, b) => a - b)[0];
+  if (at === void 0 || at < 80) return flat.slice(0, 200);
+  const start = Math.max(0, at - 60);
+  return `\u2026${flat.slice(start, start + 200)}`;
+}
+function toSearchHit(node, query) {
+  return {
+    id: node.id,
+    title: node.frontmatter.title,
+    type: node.frontmatter.type || "document",
+    tags: node.frontmatter.tags || [],
+    snippet: bodySnippet(node.body || "", query)
+  };
+}
+
 // src/nodes/routes.ts
 import { Hono as Hono8 } from "hono";
 
-// src/shared/artifact-sandbox.ts
-var ARTIFACT_SANDBOX_CSP = [
-  "sandbox allow-scripts allow-popups allow-modals",
-  "default-src 'none'",
-  "script-src 'unsafe-inline'",
-  "style-src 'unsafe-inline'",
-  "img-src data: blob:",
-  "font-src data:",
-  "connect-src 'none'",
-  "base-uri 'none'",
-  "form-action 'none'"
-].join("; ");
-function applyArtifactSandboxHeaders(c) {
-  c.header("Content-Security-Policy", ARTIFACT_SANDBOX_CSP);
-  c.header("X-Content-Type-Options", "nosniff");
-  c.header("Referrer-Policy", "no-referrer");
-}
-
 // src/nodes/markdown-export.ts
 import { parseDocument as parseDocument3 } from "@promptowl/contextnest-engine";
 function nodeToMarkdown(node) {
@@ -3933,7 +4195,17 @@ function rawNodeBody(c, response, storedRaw) {
 nodeRoutes.get("/", async (c) => {
   const nestId = c.req.param("nestId");
   const userId = c.get("userId");
-  const nodes = await listNodesForCaller(nestId, userId);
+  const q = c.req.query();
+  const limit = q.limit ? parseInt(q.limit, 10) : void 0;
+  const nodes = await listNodesForCaller(nestId, userId, {
+    ...q.type ? { type: q.type } : {},
+    ...q.tag ? { tag: q.tag } : {},
+    ...q.status ? { status: q.status } : {},
+    // Lets an owner preview what making the nest public would expose.
+    ...q.approved_only === "1" || q.approved_only === "true" ? { approvedOnly: true } : {},
+    // Ignore junk rather than 400 — a bad ?limit should not fail a listing.
+    ...limit !== void 0 && Number.isFinite(limit) && limit > 0 ? { limit } : {}
+  });
   return c.json({ count: nodes.length, nodes });
 });
 nodeRoutes.post("/", async (c) => {
@@ -3974,7 +4246,7 @@ nodeRoutes.post("/", async (c) => {
 nodeRoutes.get("/:nodeId{.+}/stewards", async (c) => {
   const nestId = c.req.param("nestId");
   const nodeId = c.req.param("nodeId");
-  const { resolveStewardsWithFallback: resolveStewardsWithFallback2 } = await import("./stewardship-service-FHJ2RBKN.js");
+  const { resolveStewardsWithFallback: resolveStewardsWithFallback2 } = await import("./stewardship-service-OHTTZFND.js");
   const { stewards, fallbackToOwner, ownerEmail } = await resolveStewardsWithFallback2(
     nestId,
     nodeId
@@ -3995,7 +4267,7 @@ nodeRoutes.get("/:nodeId{.+}/stewards", async (c) => {
 nodeRoutes.get("/:nodeId{.+}/reviews", async (c) => {
   const nestId = c.req.param("nestId");
   const nodeId = c.req.param("nodeId");
-  const { getReviewHistory: getReviewHistory2 } = await import("./review-service-JUAFYB73.js");
+  const { getReviewHistory: getReviewHistory2 } = await import("./review-service-3CCKDO5N.js");
   const history = await getReviewHistory2(nestId, nodeId);
   return c.json({ reviews: history });
 });
@@ -4076,26 +4348,21 @@ nodeRoutes.delete("/:nodeId{.+}/watchers", async (c) => {
   if (!await removeWatcher(nestId, nodeId, email)) {
     throw new NotFoundError("Not watching");
   }
-  return c.json({ watchers: await listWatchers(nestId, nodeId) });
-});
-nodeRoutes.get("/:nodeId{.+}", async (c) => {
-  const nestId = c.req.param("nestId");
-  const nodeId = c.req.param("nodeId");
-  const { storage, versions: versionManager } = await engineCache.get(nestId);
-  const userId = c.get("userId");
-  const userEmail = await resolveCallerEmail(userId);
-  if (!await canReadNode(nestId, nodeId, userId, userEmail)) {
-    return c.json(
-      { error: "Access denied \u2014 no steward assignment for this node" },
-      403
-    );
-  }
-  let node;
-  try {
-    node = await storage.readDocument(nodeId, { verifyChecksum: true });
-  } catch {
-    throw new NotFoundError(`Node not found: ${nodeId}`);
-  }
+  return c.json({ watchers: await listWatchers(nestId, nodeId) });
+});
+nodeRoutes.get("/:nodeId{.+}", async (c) => {
+  const nestId = c.req.param("nestId");
+  const nodeId = c.req.param("nodeId");
+  const { storage, versions: versionManager } = await engineCache.get(nestId);
+  const userId = c.get("userId");
+  const userEmail = await resolveCallerEmail(userId);
+  let node = await getNodeForCaller(
+    nestId,
+    { id: nodeId },
+    userId,
+    userEmail,
+    { verifyChecksum: true }
+  );
   if (node.pendingChange) {
     try {
       await scanDocumentForDrift(nestId, nodeId, userEmail || "system:read");
@@ -4124,6 +4391,7 @@ nodeRoutes.get("/:nodeId{.+}", async (c) => {
       response.collaborators = people.collaborators;
     }
   }
+  response.myGrant = await resolveNodeGrant(nestId, userId, nodeId);
   if (publicReader) {
     const approved = await getApprovedVersion(nestId, nodeId);
     if (approved != null) {
@@ -5611,30 +5879,14 @@ queryRoutes.get("/search", async (c) => {
   }
   const nestId = c.req.param("nestId");
   const { storage } = await engineCache.get(nestId);
-  const documents = await storage.discoverDocuments();
-  const terms = q.toLowerCase().split(/\s+/).filter(Boolean);
-  const matches = documents.filter((node) => {
-    const haystack = [
-      node.frontmatter.title,
-      node.body || "",
-      node.frontmatter.type || "",
-      ...node.frontmatter.tags || []
-    ].join(" ").toLowerCase();
-    return terms.every((term) => haystack.includes(term));
-  });
+  const matches = matchDocuments(await discoverForSearch(storage), q);
   const userId = c.get("userId");
   const userEmail = await resolveCallerEmail(userId);
   const accessible = await filterAccessible(nestId, userId, userEmail, matches);
   return c.json({
     query: q,
     count: accessible.length,
-    nodes: accessible.map((n) => ({
-      id: n.id,
-      title: n.frontmatter.title,
-      type: n.frontmatter.type || "document",
-      tags: n.frontmatter.tags || [],
-      snippet: (n.body || "").slice(0, 200).replace(/\n/g, " ")
-    }))
+    nodes: accessible.map((n) => toSearchHit(n, q))
   });
 });
 queryRoutes.get("/overview", async (c) => {
@@ -5674,10 +5926,6 @@ queryRoutes.get("/context", async (c) => {
 queryRoutes.get("/export", async (c) => {
   const nestId = c.req.param("nestId");
   if (c.req.query("format") === "bundle") {
-    const perm = await resolveNestPermission(nestId, c.get("userId"));
-    if (perm !== "owner" && perm !== "admin") {
-      throw new ForbiddenError("Only the nest owner or an admin can export a bundle");
-    }
     const draftsParam = c.req.query("includeDrafts");
     const includeDrafts = draftsParam === "1" || draftsParam === "true";
     const zip = await exportNestBundle(nestId, includeDrafts);
@@ -5793,6 +6041,7 @@ queryRoutes.post("/publish", async (c) => {
     await syncNodeTags(nestId, id, tags);
     created.push(id);
   }
+  if (created.length > 0 || body.context_md) await storage.regenerateIndex();
   trackEvent("nest.publish", { nestId, count: created.length });
   return c.json(
     {
@@ -5809,6 +6058,30 @@ import { Hono as Hono12 } from "hono";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
 
+// src/shared/node-id.ts
+function assertSafeNodeId(rawId) {
+  let id = rawId;
+  try {
+    id = decodeURIComponent(rawId);
+  } catch {
+  }
+  if (!id || id.length > 512) {
+    throw new ValidationError("invalid node id");
+  }
+  if (id.includes("\0") || id.includes("\\")) {
+    throw new ValidationError("invalid node id");
+  }
+  if (id.startsWith("/")) {
+    throw new ValidationError("invalid node id (absolute path)");
+  }
+  for (const seg of id.split("/")) {
+    if (seg === "" || seg === "." || seg === "..") {
+      throw new ValidationError("invalid node id (path traversal)");
+    }
+  }
+  return id;
+}
+
 // src/telemetry/trace-log.ts
 var PRUNE_EVERY = 500;
 var insertsSincePrune = 0;
@@ -5887,30 +6160,6 @@ async function listTraceEvents(filters = {}) {
 // src/mcp/workflow-tools.ts
 import { v4 as uuid8 } from "uuid";
 
-// src/shared/node-id.ts
-function assertSafeNodeId(rawId) {
-  let id = rawId;
-  try {
-    id = decodeURIComponent(rawId);
-  } catch {
-  }
-  if (!id || id.length > 512) {
-    throw new ValidationError("invalid node id");
-  }
-  if (id.includes("\0") || id.includes("\\")) {
-    throw new ValidationError("invalid node id");
-  }
-  if (id.startsWith("/")) {
-    throw new ValidationError("invalid node id (absolute path)");
-  }
-  for (const seg of id.split("/")) {
-    if (seg === "" || seg === "." || seg === "..") {
-      throw new ValidationError("invalid node id (path traversal)");
-    }
-  }
-  return id;
-}
-
 // src/workflow/run-service.ts
 import { v4 as uuid6 } from "uuid";
 var RUNNABLE_TYPES = ["agent", "skill"];
@@ -6306,6 +6555,18 @@ async function assertNoFlowCycle(db, nestId, fromNode, toNode) {
     }
   }
 }
+async function assertNoDuplicateEdge(db, nestId, fromNode, toNode, type, excludeId) {
+  const row = await db.get(
+    `SELECT id FROM edges
+      WHERE nest_id = ? AND from_node = ? AND to_node = ? AND type_id = ?` + (excludeId ? " AND id != ?" : ""),
+    excludeId ? [nestId, fromNode, toNode, type.id, excludeId] : [nestId, fromNode, toNode, type.id]
+  );
+  if (row) {
+    throw new ConflictError(
+      `a "${type.name}" connection from "${fromNode}" to "${toNode}" already exists`
+    );
+  }
+}
 var edgeRoutes = new Hono11();
 edgeRoutes.get("/", requireWorkflowPlane, async (c) => {
   const nestId = c.req.param("nestId");
@@ -6376,6 +6637,7 @@ edgeRoutes.post("/", requireWorkflowPlane, async (c) => {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const id = uuid7();
   await db.transaction(async (tx) => {
+    await assertNoDuplicateEdge(tx, nestId, fromNode, toNode, type);
     if (type.is_flow) {
       await assertNoFlowCycle(tx, nestId, fromNode, toNode);
     }
@@ -6403,6 +6665,8 @@ edgeRoutes.patch("/:id", requireWorkflowPlane, async (c) => {
     "SELECT * FROM edge_types WHERE id = ?",
     [row.type_id]
   );
+  const wasFlow = !!type.is_flow;
+  let retype = null;
   if (typeof body.type === "string" && body.type.trim()) {
     const next = await db.get(
       "SELECT * FROM edge_types WHERE nest_id = ? AND (id = ? OR LOWER(name) = LOWER(?))",
@@ -6413,9 +6677,7 @@ edgeRoutes.patch("/:id", requireWorkflowPlane, async (c) => {
         `unknown edge type "${body.type}" \u2014 define it in the registry first`
       );
     }
-    if (next.is_flow && !type.is_flow) {
-      await assertNoFlowCycle(db, nestId, row.from_node, row.to_node);
-    }
+    if (next.id !== type.id) retype = next;
     type = next;
   }
   let mode = row.condition_mode;
@@ -6429,11 +6691,19 @@ edgeRoutes.patch("/:id", requireWorkflowPlane, async (c) => {
     mode = v.mode;
     stored = v.stored;
   }
-  await db.run(
-    `UPDATE edges SET type_id = ?, condition_mode = ?, condition = ?, updated_at = ?
-      WHERE id = ?`,
-    [type.id, mode, stored, (/* @__PURE__ */ new Date()).toISOString(), id]
-  );
+  await db.transaction(async (tx) => {
+    if (retype) {
+      await assertNoDuplicateEdge(tx, nestId, row.from_node, row.to_node, retype, id);
+      if (retype.is_flow && !wasFlow) {
+        await assertNoFlowCycle(tx, nestId, row.from_node, row.to_node);
+      }
+    }
+    await tx.run(
+      `UPDATE edges SET type_id = ?, condition_mode = ?, condition = ?, updated_at = ?
+        WHERE id = ?`,
+      [type.id, mode, stored, (/* @__PURE__ */ new Date()).toISOString(), id]
+    );
+  });
   const updated = await db.get("SELECT * FROM edges WHERE id = ?", [id]);
   return c.json({ edge: toResponse(updated, type) });
 });
@@ -6768,6 +7038,7 @@ async function createEdge(ctx, args) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const id = uuid8();
   await db.transaction(async (tx) => {
+    await assertNoDuplicateEdge(tx, ctx.nestId, fromNode, toNode, type);
     if (type.is_flow) {
       await assertNoFlowCycle(tx, ctx.nestId, fromNode, toNode);
     }
@@ -6868,6 +7139,30 @@ function normalizeHops(raw) {
   if (!Number.isFinite(n)) return 2;
   return Math.max(0, Math.min(MAX_HOPS, Math.floor(n)));
 }
+function toolError(text, code) {
+  return { text, isError: true, data: { code, message: text } };
+}
+function toCallToolResult(out) {
+  if (typeof out === "string") {
+    return { content: [{ type: "text", text: out }] };
+  }
+  return {
+    content: [{ type: "text", text: out.text }],
+    structuredContent: out.data,
+    ...out.isError ? { isError: true } : {}
+  };
+}
+function summarizeNode(node, body) {
+  return {
+    id: node.id,
+    title: node.frontmatter.title,
+    description: node.frontmatter.description,
+    type: node.frontmatter.type || "document",
+    status: node.frontmatter.status || "draft",
+    tags: node.frontmatter.tags,
+    body: body ?? void 0
+  };
+}
 var TOOL_DEFINITIONS = [
   {
     name: "context_init",
@@ -6936,12 +7231,23 @@ var TOOL_DEFINITIONS = [
   },
   {
     name: "context_list",
-    description: "Browse vault contents with optional type, tag, or limit filters.",
+    description: "Browse vault contents with optional type, tag, status, or limit filters.",
     inputSchema: {
       type: "object",
       properties: {
         type: { type: "string", description: "Filter by node type" },
-        tag: { type: "string", description: "Filter by tag" },
+        tag: {
+          type: "string",
+          description: "Filter by tag (leading # optional, case-insensitive)"
+        },
+        status: {
+          type: "string",
+          description: "Filter by status: draft | pending_review | approved | published | rejected. Aliases normalized. Unlike the CLI and the OSS server, retired nodes stay in this listing whether or not you ask \u2014 here they are unpublished documents their stewards may still act on."
+        },
+        approved_only: {
+          type: "boolean",
+          description: "Return only nodes with an approved version, each served at that version rather than the live file \u2014 the view a public nest gives a stranger."
+        },
         limit: { type: "number", description: "Max nodes to return" }
       }
     }
@@ -7023,13 +7329,20 @@ var TOOL_DEFINITIONS = [
   },
   {
     name: "context_update",
-    description: "Update an existing node \u2014 append, replace content, add tags.",
+    description: "Update an existing node \u2014 replace or append content, set tags, move it through its lifecycle. Whether the edit publishes is decided by this nest's stewardship rules, not by the caller.",
     inputSchema: {
       type: "object",
       properties: {
         title: {
+          // Selects the node; it does NOT rename it. Titles are unique here
+          // precisely so MCP callers can address a document this way. Renaming
+          // is not reachable from this tool.
+          type: "string",
+          description: "Title of node to update (selects it; does not rename)"
+        },
+        id: {
           type: "string",
-          description: "Title of node to update"
+          description: 'Node id / path (e.g. "nodes/gtm/deals/win-loss-log"). Use instead of title when two nodes share a title or the title is unknown.'
         },
         content: {
           type: "string",
@@ -7041,9 +7354,19 @@ var TOOL_DEFINITIONS = [
           items: { type: "string" },
           description: "Tags to add"
         },
-        scope: { type: "string", description: "New scope" }
-      },
-      required: ["title"]
+        status: {
+          type: "string",
+          description: "New lifecycle status: draft | pending_review | approved | published | rejected. Aliases are normalized."
+        },
+        changeNote: {
+          type: "string",
+          description: "Why this changed \u2014 recorded in version history"
+        }
+      }
+      // Neither is required alone — one of them is (the engine catalog's
+      // `.refine(id || title)`, which JSON Schema can't express here).
+      // `title` was required, which made this tool unreachable for `ctx`:
+      // it addresses nodes by id and never sends a title.
     }
   },
   {
@@ -7110,7 +7433,7 @@ var TOOL_DEFINITIONS = [
     // repo's governance tables, which the engine doesn't own. Adopt an engine
     // descriptor here if the operation is ever promoted upstream.
     name: "context_request_deletion",
-    description: "Ask for something to be deleted when you can't delete it yourself. Flags a document, a folder (with everything in it), or the whole nest for a nest owner/admin to action. Nothing is removed by this call \u2014 it opens a request, and the person who resolves it either deletes the target or declines with a note. Use this instead of context_delete when that returns a permission error, or when the document belongs to someone else.",
+    description: "Ask for something to be deleted when you can't delete it yourself. Flags a document, a folder (with everything in it), or the whole nest for a nest owner/admin to action. Nothing is removed by this call \u2014 it opens a request, and the person who resolves it either deletes the target or rejects it with a note. Use this instead of context_delete when that returns a permission error, or when the document belongs to someone else.",
     inputSchema: {
       type: "object",
       properties: {
@@ -7143,14 +7466,14 @@ var TOOL_DEFINITIONS = [
       properties: {
         status: {
           type: "string",
-          description: "pending (default) or declined \u2014 declined shows past verdicts and their notes."
+          description: '"pending" (default) or "declined" \u2014 past rejections and their notes.'
         }
       }
     }
   },
   {
     name: "context_resolve_deletion",
-    description: "Action a deletion request: delete the flagged document/folder/nest, or decline it with a note explaining why it stays. Owner/admin only. Declining tells the requester the verdict; deleting is irreversible.",
+    description: "Action a deletion request: delete the flagged document/folder/nest, or reject it with a note explaining why it stays. Owner/admin only. Rejecting tells the requester the verdict; deleting is irreversible.",
     inputSchema: {
       type: "object",
       properties: {
@@ -7160,11 +7483,11 @@ var TOOL_DEFINITIONS = [
         },
         action: {
           type: "string",
-          description: '"delete" to honour it, "decline" to keep the target'
+          description: '"delete" to honour it, "decline" to reject it and keep the target'
         },
         note: {
           type: "string",
-          description: "Why you declined. Required when action is decline."
+          description: 'Why you rejected it. Required when action is "decline".'
         }
       },
       required: ["request_id", "action"]
@@ -7234,9 +7557,13 @@ var TOOL_DEFINITIONS = [
     inputSchema: {
       type: "object",
       properties: {
-        title: { type: "string", description: "Title of the node" }
-      },
-      required: ["title"]
+        title: { type: "string", description: "Title of the node" },
+        id: {
+          type: "string",
+          description: 'Node id / path (e.g. "nodes/gtm/deals/win-loss-log"). Use instead of title when two nodes share a title or the title is unknown.'
+        }
+      }
+      // One of id or title — see context_update.
     }
   },
   {
@@ -7347,7 +7674,7 @@ async function resolveTargetNode(storage, args) {
   if (!args.id && !args.title) return "Provide a title or an id.";
   if (args.id) {
     try {
-      return await storage.readDocument(args.id);
+      return await storage.readDocument(assertSafeNodeId(args.id));
     } catch {
       return `Node not found: ${args.id}`;
     }
@@ -7365,36 +7692,47 @@ async function runTool(toolName, args, ctx) {
   const { storage, queryEngine, versionManager, nestId, userId, userEmail } = ctx;
   switch (toolName) {
     case "context_init": {
-      const content = await storage.readContextMd();
-      if (!content)
+      const { context_md } = await engineApi.run(
+        "context_init",
+        {},
+        await opContext(nestId, userEmail)
+      );
+      if (!context_md)
         return "No CONTEXT.md found. Use context_overview to see what's available.";
       return `# Vault Instructions (CONTEXT.md)
 
-${content}`;
+${context_md}`;
     }
     case "context_overview": {
-      const docs = await storage.discoverDocuments();
+      const { total } = await engineApi.run(
+        "context_init",
+        {},
+        await opContext(nestId, userEmail)
+      );
+      const visible = await listNodesForCallerByEmail(nestId, userEmail, {});
       const types = {};
       const tags = {};
-      for (const n of docs) {
-        const t = n.frontmatter.type || "document";
-        types[t] = (types[t] || 0) + 1;
-        for (const tag of n.frontmatter.tags || []) tags[tag] = (tags[tag] || 0) + 1;
-      }
-      const typeList = Object.entries(types).sort((a, b) => b[1] - a[1]).map(([t, c]) => `  ${t}: ${c}`).join("\n");
-      const tagList = Object.entries(tags).sort((a, b) => b[1] - a[1]).map(([t, c]) => `  ${t}: ${c}`).join("\n");
-      const nodeList = docs.map(
-        (n, i) => `${i + 1}. **${n.frontmatter.title}** [${n.frontmatter.type || "document"}] ${(n.frontmatter.tags || []).slice(0, 4).join(" ")}
-   ${(n.body || "").slice(0, 120).replace(/\n/g, " ")}`
+      for (const n of visible) {
+        types[n.type] = (types[n.type] || 0) + 1;
+        for (const tag of n.tags || []) tags[tag] = (tags[tag] || 0) + 1;
+      }
+      const fmt = (counts) => Object.entries(counts).sort((a, b) => b[1] - a[1]).map(([k, c]) => `  ${k}: ${c}`).join("\n");
+      const nodeList = visible.map(
+        (n, i) => `${i + 1}. **${n.title}** [${n.type}] ${(n.tags || []).slice(0, 4).join(" ")}
+   ${(n.content || "").slice(0, 120).replace(/\n/g, " ")}`
       ).join("\n\n");
+      const withheld = total - visible.length;
+      const note = withheld > 0 ? `
+_${withheld} node(s) not visible to you._
+` : "";
       return `# Vault Overview
-**Total nodes:** ${docs.length}
-
+**Total nodes:** ${visible.length}
+${note}
 ## Types
-${typeList}
+${fmt(types)}
 
 ## Tags
-${tagList}
+${fmt(tags)}
 
 ## All Nodes
 
@@ -7416,14 +7754,26 @@ ${nodeList}`;
         ].join(" ").toLowerCase();
         return terms.every((t) => hay.includes(t));
       });
-      if (!matches.length) return `No nodes matched search: "${args.query}"`;
+      if (!matches.length)
+        return {
+          text: `No nodes matched search: "${args.query}"`,
+          data: { results: [] }
+        };
       const results = matches.map(
         ({ node: n, body }, i) => `${i + 1}. **${n.frontmatter.title}** [${n.frontmatter.type || "document"}] ${(n.frontmatter.tags || []).join(" ")}
    ${(body || "").slice(0, 200).replace(/\n/g, " ")}`
       ).join("\n\n");
-      return `Found ${matches.length} node(s) matching "${args.query}":
-
-${results}`;
+      return {
+        text: `Found ${matches.length} node(s) matching "${args.query}":
+
+${results}`,
+        // Same gated bodies the prose is built from — `resolveLlmBody`
+        // already refused everything this caller may not read. No `score`:
+        // this is a term-containment filter, not a ranked search.
+        data: {
+          results: matches.map(({ node: n, body }) => summarizeNode(n, body))
+        }
+      };
     }
     case "context_table_query": {
       const result = await queryTableNode(
@@ -7440,61 +7790,119 @@ ${results}`;
 ${lines.join("\n")}`;
     }
     case "context_query": {
-      const result = await queryEngine.query(args.query, {
-        hops: normalizeHops(args.hops)
-      });
+      const { documents, traversal } = await engineApi.run(
+        "context_query",
+        { query: args.query, hops: normalizeHops(args.hops) },
+        await opContext(nestId, userEmail)
+      );
       const visibility = await Promise.all(
-        result.documents.map(async (n) => ({
-          node: n,
-          visible: await resolveLlmBody(ctx, n) !== null
+        documents.map(async (d) => ({
+          doc: d,
+          body: await resolveLlmBody(ctx, {
+            id: d.id,
+            body: d.body ?? "",
+            frontmatter: { title: d.title }
+          })
         }))
       );
-      const nodes = visibility.filter((e) => e.visible).map((e) => e.node);
-      if (!nodes.length) return `No nodes matched: ${args.query}`;
-      const list = nodes.map(
-        (n, i) => `${i + 1}. **${n.frontmatter.title}** [${n.frontmatter.type || "document"}] ${(n.frontmatter.tags || []).join(" ")}`
-      ).join("\n\n");
-      return `Found ${nodes.length} node(s) for \`${args.query}\`:
-
-${list}`;
+      const visible = visibility.filter((e) => e.body !== null);
+      const nodes = visible.map((e) => e.doc);
+      if (!nodes.length)
+        return {
+          text: `No nodes matched: ${args.query}`,
+          data: { documents: [], traversal }
+        };
+      const list = nodes.map((n, i) => `${i + 1}. **${n.title}** [${n.type}] ${(n.tags || []).join(" ")}`).join("\n\n");
+      return {
+        text: `Found ${nodes.length} node(s) for \`${args.query}\`:
+
+${list}`,
+        // The engine already hands back catalog `nodeSummary` shapes — only
+        // `body` is swapped for the gated one resolveLlmBody returned.
+        // `source_nodes` is deliberately absent: this handler never gates
+        // them, so serving them would hand out content the prose refuses.
+        data: {
+          documents: visible.map((e) => ({ ...e.doc, body: e.body ?? void 0 })),
+          traversal
+        }
+      };
     }
     case "context_get": {
-      const docs = await storage.discoverDocuments();
       let node;
-      if (args.title) {
-        node = docs.find(
-          (n) => n.frontmatter.title.toLowerCase() === args.title.toLowerCase()
+      try {
+        node = await getNodeForCaller(
+          nestId,
+          args.title ? { title: args.title } : { id: args.id },
+          ctx.userId,
+          userEmail
+        );
+      } catch {
+        return toolError(
+          `Node not found: ${args.title || args.id}`,
+          "DOCUMENT_NOT_FOUND"
         );
-      } else if (args.id) {
-        node = docs.find((n) => n.id === args.id);
       }
-      if (!node) return `Node not found: ${args.title || args.id}`;
       const body = await resolveLlmBody(ctx, node);
       if (body === null) {
-        return `Node "${node.frontmatter.title}" has no approved version yet \u2014 not available to AI.`;
+        return toolError(
+          `Node "${node.frontmatter.title}" has no approved version yet \u2014 not available to AI.`,
+          "UNAUTHORIZED_ACTION"
+        );
       }
       const meta = [
         `**Title:** ${node.frontmatter.title}`,
         `**Type:** ${node.frontmatter.type || "document"}`,
         node.frontmatter.tags?.length ? `**Tags:** ${node.frontmatter.tags.join(" ")}` : null
       ].filter(Boolean).join("\n");
-      return `${meta}
+      return {
+        text: `${meta}
 
 ---
 
-${body || "(no content)"}`;
+${body || "(no content)"}`,
+        // `body` is the gated one, not node.body — under stewardship that is
+        // the APPROVED snapshot, which can be older than the live draft this
+        // frontmatter came from. So the payload carries only the fields the
+        // prose above already reports, none of which claim to describe a
+        // specific version. `version`, `status`, `checksum` and the
+        // timestamps are deliberately absent: they describe the draft, and
+        // pairing them with an approved body would misdescribe it (checksum
+        // would also be a draft hash — see context_versions). `raw` is absent
+        // too: no include_raw input here (Phase 2).
+        data: {
+          id: node.id,
+          frontmatter: {
+            title: node.frontmatter.title,
+            description: node.frontmatter.description,
+            type: node.frontmatter.type || "document",
+            tags: node.frontmatter.tags
+          },
+          body
+        }
+      };
     }
     case "context_list": {
       const nodes = await listNodesForCallerByEmail(nestId, userEmail, {
         type: args.type,
         tag: args.tag,
+        status: args.status,
+        approvedOnly: args.approved_only === true,
         limit: args.limit || 50
       });
-      if (!nodes.length) return "No nodes found with the given filters.";
+      const documents = nodes.map((n) => ({
+        id: n.id,
+        title: n.title,
+        description: n.description,
+        type: n.type || "document",
+        status: n.status || "draft",
+        tags: n.tags
+      }));
+      if (!nodes.length)
+        return { text: "No nodes found with the given filters.", data: { documents } };
       const list = nodes.map((n, i) => `${i + 1}. **${n.title}** [${n.type}]`).join("\n");
-      return `${nodes.length} node(s):
+      return { text: `${nodes.length} node(s):
 
-${list}`;
+${list}`, data: { documents } };
     }
     case "context_resolve": {
       const result = await queryEngine.query(args.selector, {
@@ -7592,7 +8000,10 @@ ${sections}`;
     }
     case "context_create": {
       if (!await canCreateInNest(nestId, userEmail)) {
-        return "You don't have permission to create documents in this nest.";
+        return toolError(
+          "You don't have permission to create documents in this nest.",
+          "UNAUTHORIZED_ACTION"
+        );
       }
       const wanted = String(args.title ?? "").toLowerCase();
       return withNodeWriteLock(nodeWriteKey(nestId, "*create*"), async () => {
@@ -7601,9 +8012,19 @@ ${sections}`;
           (n) => String(n.frontmatter.title ?? "").toLowerCase() === wanted
         );
         if (twin) {
-          return `A node titled "${twin.frontmatter.title}" already exists (${twin.id}). Titles must be unique \u2014 MCP tools resolve documents by title, so a second one would be unreachable. Use context_update to change it, context_move to refile it, or create this one under a different title.`;
+          const twinVersions = await getVersions(nestId, twin.id);
+          if (twinVersions.length === 0) {
+            return toolError(
+              `A node titled "${twin.frontmatter.title}" already exists (${twin.id}) but has no version history, which is why it doesn't show up in a read or a draft list. It may be an interrupted create or a document whose import never finished. Write into it with context_update "${twin.id}" to keep whatever is there, or remove it with context_delete "${twin.id}" and create again \u2014 check its content first.`,
+              "DOCUMENT_ALREADY_EXISTS"
+            );
+          }
+          return toolError(
+            `A node titled "${twin.frontmatter.title}" already exists (${twin.id}). Titles must be unique \u2014 MCP tools resolve documents by title, so a second one would be unreachable. Use context_update to change it, context_move to refile it, or create this one under a different title.`,
+            "DOCUMENT_ALREADY_EXISTS"
+          );
         }
-        const { node } = await createNode(
+        const { node, version } = await createNode(
           nestId,
           {
             title: args.title,
@@ -7615,42 +8036,75 @@ ${sections}`;
           },
           userEmail
         );
-        return `Created node: **${args.title}** (${node.id}) \u2014 status: ${node.frontmatter.status}`;
+        return {
+          text: `Created node: **${args.title}** (${node.id}) \u2014 status: ${node.frontmatter.status}`,
+          // checkpoint is null by construction: this server seals nothing —
+          // a write becomes live through steward review, not a checkpoint.
+          data: {
+            id: node.id,
+            version,
+            status: node.frontmatter.status,
+            checkpoint: null
+          }
+        };
       });
     }
     case "context_update": {
-      const docs = await storage.discoverDocuments();
-      const node = docs.find(
-        (n) => n.frontmatter.title.toLowerCase() === args.title.toLowerCase()
-      );
-      if (!node) return `Node not found: ${args.title}`;
+      const node = await resolveTargetNode(storage, args);
+      if (typeof node === "string") return toolError(node, "DOCUMENT_NOT_FOUND");
+      const label = args.id ? node.frontmatter.title : args.title;
       const editCheck = await canUserEdit(nestId, node.id, userEmail);
       if (!editCheck.allowed) {
-        return `You don't have permission to edit "${args.title}": ${editCheck.reason}`;
+        return toolError(
+          `You don't have permission to edit "${label}": ${editCheck.reason}`,
+          "UNAUTHORIZED_ACTION"
+        );
       }
-      const { node: updated } = await updateNode(
+      const mergedTags = args.tags ? [.../* @__PURE__ */ new Set([...node.frontmatter.tags || [], ...args.tags])] : void 0;
+      const { node: updated, version } = await updateNode(
         nestId,
         node.id,
         {
           content: args.content,
           append: args.append,
-          tags: args.tags
+          tags: mergedTags,
+          status: args.status,
+          changeNote: args.changeNote
         },
         userEmail
       );
-      return `Updated node: **${updated.frontmatter.title}**`;
+      return {
+        text: `Updated node: **${updated.frontmatter.title}** \u2014 v${version}, status: ${updated.frontmatter.status}`,
+        // checkpoint null — see context_create.
+        data: {
+          id: updated.id,
+          version,
+          status: updated.frontmatter.status,
+          checkpoint: null
+        }
+      };
     }
     case "context_delete": {
       const node = await resolveTargetNode(storage, args);
-      if (typeof node === "string") return node;
+      if (typeof node === "string") return toolError(node, "DOCUMENT_NOT_FOUND");
       const deleteCheck = await canUserEdit(nestId, node.id, userEmail);
       if (!deleteCheck.allowed) {
-        return `You don't have permission to delete "${node.frontmatter.title}": ${deleteCheck.reason}
+        return toolError(
+          `You don't have permission to delete "${node.frontmatter.title}": ${deleteCheck.reason}
 
-Use context_request_deletion to ask a nest owner/admin to delete it, with a reason.`;
+Use context_request_deletion to ask a nest owner/admin to delete it, with a reason.`,
+          "UNAUTHORIZED_ACTION"
+        );
       }
       await deleteNode(nestId, node.id, userEmail);
-      return `Deleted node: **${node.frontmatter.title}** (${node.id})`;
+      return {
+        text: `Deleted node: **${node.frontmatter.title}** (${node.id})`,
+        data: {
+          id: node.id,
+          title: node.frontmatter.title,
+          deleted: true
+        }
+      };
     }
     case "context_move": {
       if (typeof args.folder !== "string") {
@@ -7718,6 +8172,9 @@ ${sections}`;
         return "reason is required \u2014 say why it should be deleted; that is what the admin judges.";
       }
       if (args.nest === true) {
+        if (!await canRequestDeletion({ nestId, userId, userEmail, nodeId: "" })) {
+          return "Only an editor, a nest admin, or the nest owner can request the deletion of a nest.";
+        }
         const request2 = await requestDeletion({
           nestId,
           nodeId: nestId,
@@ -7726,10 +8183,13 @@ ${sections}`;
           reason,
           baseUrl: ctx.baseUrl
         });
-        return `Requested deletion of the **entire nest**. A nest owner or admin will delete it or decline.
+        return `Requested deletion of the **entire nest**. A nest owner or admin will delete it or reject the request.
 Request id: \`${request2.id}\``;
       }
       if (typeof args.folder === "string" && args.folder.trim()) {
+        if (!await canRequestDeletion({ nestId, userId, userEmail, nodeId: "" })) {
+          return "Only an editor, a nest admin, or the nest owner can request the deletion of a folder.";
+        }
         const folder = args.folder.trim().replace(/^\/+|\/+$/g, "").replace(/^nodes\//, "");
         const docs = await storage.discoverDocuments();
         const inside = docs.filter((d) => isIdUnderFolder(d.id, folder));
@@ -7744,7 +8204,7 @@ Request id: \`${request2.id}\``;
           reason,
           baseUrl: ctx.baseUrl
         });
-        return `Requested deletion of folder **${folder}** (${inside.length} document(s) inside). A nest owner or admin will delete it or decline.
+        return `Requested deletion of folder **${folder}** (${inside.length} document(s) inside). A nest owner or admin will delete it or reject the request.
 Request id: \`${request2.id}\``;
       }
       const node = await resolveTargetNode(storage, args);
@@ -7752,6 +8212,14 @@ Request id: \`${request2.id}\``;
       if (!await canReadNode(nestId, node.id, userId, userEmail)) {
         return `Node not found: ${node.id}`;
       }
+      if (!await canRequestDeletion({
+        nestId,
+        userId,
+        userEmail,
+        nodeId: node.id
+      })) {
+        return "Only an editor, a nest admin, or the nest owner can request the deletion of a document.";
+      }
       const request = await requestDeletion({
         nestId,
         nodeId: node.id,
@@ -7760,19 +8228,19 @@ Request id: \`${request2.id}\``;
         reason,
         baseUrl: ctx.baseUrl
       });
-      return `Requested deletion of **${node.frontmatter.title}**. A nest owner or admin will delete it or decline \u2014 nothing is removed yet.
+      return `Requested deletion of **${node.frontmatter.title}**. A nest owner or admin will delete it or reject the request \u2014 nothing is removed yet.
 Request id: \`${request.id}\``;
     }
     case "context_deletion_queue": {
       const status = args.status === "declined" ? "declined" : "pending";
       const requests = await listDeletionRequests({ nestId, status });
       if (requests.length === 0) {
-        return status === "pending" ? "No deletion requests waiting. All caught up!" : "No declined deletion requests.";
+        return status === "pending" ? "No deletion requests waiting. All caught up!" : "No rejected deletion requests.";
       }
       const list = requests.map((r, i) => {
         const kind = r.targetType === "document" ? "" : `${r.targetType}: `;
         const verdict = r.status === "declined" ? `
-   Declined by ${r.resolvedBy}: "${r.resolutionNote}"` : "";
+   Rejected by ${r.resolvedBy}: "${r.resolutionNote}"` : "";
         return `${i + 1}. **${kind}${r.title || r.nodeId}**
    Asked by ${r.requestedBy}: "${r.reason}"
    Request id: \`${r.id}\`${verdict}`;
@@ -7800,7 +8268,7 @@ ${list}`;
       if (action === "decline") {
         const note = typeof args.note === "string" ? args.note.trim() : "";
         if (!note) {
-          return "note is required when declining \u2014 the requester is told why it stays.";
+          return "note is required when rejecting \u2014 the requester is told why it stays.";
         }
         await declineDeletion({
           nestId,
@@ -7809,7 +8277,7 @@ ${list}`;
           note,
           baseUrl: ctx.baseUrl
         });
-        return `Declined the deletion request for **${label}**. It stays, and ${request.requestedBy} has been told why.`;
+        return `Rejected the deletion request for **${label}**. It stays, and ${request.requestedBy} has been told why.`;
       }
       if (request.targetType === "nest") {
         await deleteNest(nestId);
@@ -7880,13 +8348,17 @@ Submit one with \`context_submit_review\`.`;
       const node = docs.find(
         (n) => n.frontmatter.title.toLowerCase() === args.title.toLowerCase()
       );
-      if (!node) return `Node not found: ${args.title}`;
+      if (!node) return toolError(`Node not found: ${args.title}`, "DOCUMENT_NOT_FOUND");
       const submitCheck = await canUserEdit(ctx.nestId, node.id, userEmail);
       if (!submitCheck.allowed) {
-        return `You don't have permission to submit "${args.title}" for review: ${submitCheck.reason}`;
+        return toolError(
+          `You don't have permission to submit "${args.title}" for review: ${submitCheck.reason}`,
+          "UNAUTHORIZED_ACTION"
+        );
       }
       const currentVersion = await getCurrentVersion(ctx.nestId, node.id);
-      if (currentVersion === 0) return `No versions found for "${args.title}"`;
+      if (currentVersion === 0)
+        return toolError(`No versions found for "${args.title}"`, "VERSION_NOT_FOUND");
       try {
         const request = await submitForReview({
           nestId: ctx.nestId,
@@ -7905,9 +8377,33 @@ Submit one with \`context_submit_review\`.`;
 
 **Stewards who can review:**
 ${resolved.map((r) => `- ${r.steward.userEmail} (${r.source})`).join("\n")}` : "";
-        return `Submitted "${args.title}" v${currentVersion} for review (${request.priority} priority).${stewardList}`;
+        return {
+          text: `Submitted "${args.title}" v${currentVersion} for review (${request.priority} priority).${stewardList}`,
+          // No catalog shape to conform to — `context_submit_review` is a
+          // governance-namespace operation and that namespace is declared but
+          // unimplemented in the engine (`api/index.ts`, NAMESPACES). So this
+          // is the review state the handler already computed, and nothing
+          // more: no `version`/`checkpoint` at the top level, because this
+          // operation writes no new version and seals no checkpoint — it
+          // points a review request at the version that already existed.
+          // Built from the same gated values the prose above is built from
+          // (`request`, `resolved`), never re-read past the permission check.
+          data: {
+            id: node.id,
+            submitted: true,
+            review: {
+              id: request.id,
+              version: request.version,
+              status: request.status,
+              priority: request.priority,
+              requested_by: request.requestedBy,
+              requested_at: request.requestedAt
+            },
+            reviewers: resolved.map((r) => r.steward.userEmail)
+          }
+        };
       } catch (err) {
-        return `Failed to submit: ${err.message}`;
+        return toolError(`Failed to submit: ${err.message}`, "INTERNAL");
       }
     }
     case "context_approve": {
@@ -7951,23 +8447,46 @@ Reason: ${args.note}`;
       }
     }
     case "context_versions": {
-      const docs = await storage.discoverDocuments();
-      const node = docs.find(
-        (n) => n.frontmatter.title.toLowerCase() === args.title.toLowerCase()
-      );
-      if (!node) return `Node not found: ${args.title}`;
+      const node = await resolveTargetNode(storage, args);
+      if (typeof node === "string") return toolError(node, "DOCUMENT_NOT_FOUND");
+      const label = args.id ? node.frontmatter.title : args.title;
       const allVersions = await getVersions(ctx.nestId, node.id);
       const approved = await getApprovedVersion(ctx.nestId, node.id);
       if (allVersions.length === 0) {
-        return `No version history for "${args.title}".`;
+        return {
+          text: `No version history for "${label}".`,
+          data: { id: node.id, approved_version: approved ?? null, versions: [] }
+        };
       }
       const list = allVersions.map(
         (v) => `- **v${v.version}** ${v.status}${v.version === approved ? " (AI-active)" : ""} \u2014 by ${v.editedBy} at ${v.editedAt}${v.changeNote ? ` "${v.changeNote}"` : ""}`
       ).join("\n");
-      return `# Version History: ${args.title}
+      return {
+        text: `# Version History: ${label}
 **Current:** v${allVersions[0]?.version || 0} | **AI-active:** ${approved ? `v${approved}` : "none"}
 
-${list}`;
+${list}`,
+        // Five catalog fields have no equivalent here and are omitted rather
+        // than faked: `keyframe_interval` and `keyframe` (content lives on
+        // disk — there is no keyframe+diff model), `chain_hash` (integrity is
+        // server-side, not a per-version chain), `content_hash` (the column
+        // exists but is conflict-detection state this tool has never served,
+        // and it is ungated), and `published_at` (a version carries a
+        // lifecycle status, not a publish timestamp). `status` and
+        // `approved_version` are the community equivalent — the same two
+        // facts the prose above reports.
+        data: {
+          id: node.id,
+          approved_version: approved ?? null,
+          versions: allVersions.map((v) => ({
+            version: v.version,
+            status: v.status,
+            edited_by: v.editedBy,
+            edited_at: v.editedAt,
+            note: v.changeNote
+          }))
+        }
+      };
     }
     case "context_assign_steward": {
       const scope = args.scope;
@@ -8025,8 +8544,8 @@ ${list}`;
       if (!target) return "target is required (a node id or folder prefix).";
       if (!["read", "write"].includes(role)) return "role must be read or write.";
       try {
-        const { createGrant: createGrant2 } = await import("./grants-service-O4AO326A.js");
-        const db = (await import("./client-NFUHPLLM.js")).getDb();
+        const { createGrant: createGrant2 } = await import("./grants-service-4NXPBYWD.js");
+        const db = (await import("./client-OBS5HOTA.js")).getDb();
         const { normalizeEmail: normalizeEmail2 } = await import("./email-R7DFS6E5.js");
         const e = normalizeEmail2(String(args.email || ""));
         if (!e) return "email is required.";
@@ -8119,7 +8638,7 @@ function createMcpServerForNest(nestId, userId, userEmail, baseUrl) {
     }
     server.tool(tool.name, tool.description, shape, async (args) => {
       const engine = await engineCache.get(nestId);
-      const text = await handleToolCall(tool.name, args, {
+      const out = await handleToolCall(tool.name, args, {
         storage: engine.storage,
         queryEngine: engine.query,
         versionManager: engine.versions,
@@ -8128,7 +8647,7 @@ function createMcpServerForNest(nestId, userId, userEmail, baseUrl) {
         userEmail,
         baseUrl
       });
-      return { content: [{ type: "text", text }] };
+      return toCallToolResult(out);
     });
   }
   return server;
@@ -9487,7 +10006,7 @@ function createServerMcp(userId, userEmail, nestScope, baseUrl) {
       shape[key] = field;
     }
     server.tool(tool.name, tool.description, shape, async (args) => {
-      const text = await handleServerToolCall(
+      const out = await handleServerToolCall(
         tool.name,
         args,
         userId,
@@ -9495,7 +10014,7 @@ function createServerMcp(userId, userEmail, nestScope, baseUrl) {
         nestScope,
         baseUrl
       );
-      return { content: [{ type: "text", text }] };
+      return toCallToolResult(out);
     });
   }
   return server;
@@ -9615,6 +10134,11 @@ Streamable HTTP, stateless. Two endpoints:
   (new document in a writable nest; a \`folder\` path creates the folder).
 - \`${B}/nests/<nest-id>/mcp\` \u2014 per-nest, full toolset including writes and
   governance (create/update, submit/approve/reject, stewards, sharing).
+  Sharing a slice is one call: \`context_grant\` with
+  \`{ "email", "target_type": "document" | "folder", "target", "role": "read" | "write" }\`
+  \u2014 \`target\` is a node id (\`nodes/win-loss-log\`) or a folder prefix
+  (\`nodes/gtm/deals\`). The recipient reaches exactly that document, or
+  everything under that folder, and nothing else in the nest. Owner/admin only.
 
 Claude Code / Cursor / VS Code connect natively via HTTP with the
 \`Authorization: Bearer\` header. Claude Desktop needs the mcp-remote bridge:
@@ -9623,20 +10147,9 @@ Claude Code / Cursor / VS Code connect natively via HTTP with the
 npx -y mcp-remote ${B}/mcp --header "Authorization: Bearer <api-key>"
 \`\`\`
 
-## ctx CLI (npm: @promptowl/contextnest-cli)
-
-\`npm i -g @promptowl/contextnest-cli\`
-
-- \`ctx push --server ${B} --nest <nest-id> --key <api-key>\` \u2014 upload a local
-  vault into a nest (add \`--include-drafts\` for unpublished nodes).
-- All other ctx commands (\`query\`, \`add\`, \`search\`, \`checkpoint\`) operate on
-  a LOCAL vault directory only. For remote reads use the API or MCP above \u2014
-  there is currently no remote \`ctx query\`.
-
 ## npm packages
 
 - \`@promptowl/contextnest-community\` \u2014 this server
-- \`@promptowl/contextnest-cli\` \u2014 the ctx CLI
 - \`@promptowl/contextnest-engine\` \u2014 vault storage + selector/graph engine
 
 ## Conventions
@@ -10215,6 +10728,25 @@ function denyUnlessNestManager(c, what) {
     403
   );
 }
+async function mayRequestDeletion(c, nestId, nodeId) {
+  return canRequestDeletion({
+    nestId,
+    userId: c.get("userId"),
+    userEmail: await getUserEmail4(c),
+    nodeId,
+    // The middleware promotes open-mode callers; resolving fresh would miss it.
+    permission: c.get("nestPermission")
+  });
+}
+function denyUnlessEditor(allowed, c, what) {
+  if (allowed) return null;
+  return c.json(
+    {
+      error: `Only an editor, a nest admin, or the nest owner can request the deletion of ${what}.`
+    },
+    403
+  );
+}
 governanceRoutes.post("/delete-folder", async (c) => {
   const nestId = c.req.param("nestId");
   const denied = denyUnlessNestManager(c, "a folder");
@@ -10232,6 +10764,12 @@ governanceRoutes.post("/delete-folder", async (c) => {
 });
 governanceRoutes.post("/request-deletion", async (c) => {
   const nestId = c.req.param("nestId");
+  const denied = denyUnlessEditor(
+    await mayRequestDeletion(c, nestId, ""),
+    c,
+    "a folder or a nest"
+  );
+  if (denied) return denied;
   const body = await c.req.json().catch(() => ({}));
   const reason = body.reason?.trim();
   if (!reason) {
@@ -10322,6 +10860,16 @@ governanceRoutes.post("/deletion-requests/:id/decline", async (c) => {
   if (!request) return c.json({ error: "Deletion request not found" }, 404);
   return c.json({ request });
 });
+governanceRoutes.post("/deletion-requests/:id/withdraw", async (c) => {
+  const nestId = c.req.param("nestId");
+  const request = await withdrawDeletionRequest({
+    nestId,
+    id: c.req.param("id"),
+    withdrawnBy: await getUserEmail4(c)
+  });
+  if (!request) return c.json({ error: "Deletion request not found or not yours" }, 404);
+  return c.json({ withdrawn: true, request });
+});
 governanceRoutes.get("/feed", async (c) => {
   const nestId = c.req.param("nestId");
   const filterRaw = c.req.query("filter");
@@ -10424,7 +10972,14 @@ governanceNodeRoutes.get("/:nodeId{.+}/versions", async (c) => {
   return c.json({
     versions: enriched,
     approvedVersion: approved,
-    currentVersion: allVersions[0]?.version || 0
+    currentVersion: allVersions[0]?.version || 0,
+    // Verdicts on out-of-band edits. A rejection commits no content, so it has
+    // no version row to hang off — it lives in the engine's chain-event log and
+    // rides alongside the version list rather than inside it.
+    externalEditVerdicts: await listExternalEditVerdicts(
+      nestId,
+      nodeId
+    )
   });
 });
 governanceNodeRoutes.get("/:nodeId{.+}/versions/:version{[0-9]+}", async (c) => {
@@ -10572,6 +11127,12 @@ governanceNodeRoutes.post("/:nodeId{.+}/request-deletion", async (c) => {
   if (!await canReadNode(nestId, nodeId, c.get("userId"), userEmail)) {
     return c.json({ error: `Node not found: ${nodeId}` }, 404);
   }
+  const denied = denyUnlessEditor(
+    await mayRequestDeletion(c, nestId, nodeId),
+    c,
+    "a document"
+  );
+  if (denied) return denied;
   const { storage } = await engineCache.get(nestId);
   try {
     await storage.readDocument(nodeId);
@@ -10606,7 +11167,9 @@ governanceNodeRoutes.post(
       return c.json({
         approved: true,
         version: result.versionEntry.version,
-        chainEvent: result.chainEvent.event_id
+        chainEvent: result.chainEvent.event_id,
+        // As on reject: false means the verdict never reached the audit log.
+        historyRecorded: result.historyRecorded
       });
     } catch (err) {
       console.error(
@@ -10641,7 +11204,10 @@ governanceNodeRoutes.post(
       });
       return c.json({
         rejected: true,
-        chainEvent: result.chainEvent.event_id
+        chainEvent: result.chainEvent.event_id,
+        // False means the edit was rejected but the audit entry did not land —
+        // the caller is not shown a clean success (server log carries why).
+        historyRecorded: result.historyRecorded
       });
     } catch (err) {
       return c.json({ error: err.message }, 400);
@@ -10886,6 +11452,13 @@ function createApp() {
     "*",
     corsOrigins === "*" ? cors({ origin: "*" }) : cors({ origin: corsOrigins, credentials: true })
   );
+  const frameAncestors = `frame-ancestors ${config.FRAME_ANCESTORS}`;
+  app.use("*", async (c, next) => {
+    await next();
+    const existing = c.res.headers.get("Content-Security-Policy");
+    const merged = mergeFrameAncestors(existing, frameAncestors);
+    if (merged !== existing) c.header("Content-Security-Policy", merged);
+  });
   const ASSET_UPLOAD_PATH = /^\/nests\/[^/]+\/assets\/?$/;
   app.use("*", async (c, next) => {
     const lenStr = c.req.header("Content-Length");
@@ -11666,6 +12239,38 @@ function createApp() {
       users: usersRow.c
     });
   });
+  app.use("/search", flexAuthMiddleware);
+  app.get("/search", async (c) => {
+    const q = (c.req.query("q") || "").trim();
+    if (!q) throw new ValidationError("q query parameter is required");
+    const limit = Math.min(Math.max(Number(c.req.query("limit")) || 20, 1), 50);
+    const userId = c.get("userId");
+    const userEmail = await resolveCallerEmail(userId);
+    const perNest = await Promise.all(
+      (await listVisibleNests(userId, { readable: true })).map(async (nest) => {
+        try {
+          const { storage } = await engineCache.get(nest.id);
+          const matches = matchDocuments(await discoverForSearch(storage), q);
+          if (matches.length === 0) return [];
+          const accessible = await filterAccessible(nest.id, userId, userEmail, matches);
+          return accessible.map((n) => ({
+            ...toSearchHit(n, q),
+            nest_id: nest.id,
+            nest_name: nest.name ?? nest.id
+          }));
+        } catch (e) {
+          console.error("[search] skipped nest", nest.id, e);
+          return [];
+        }
+      })
+    );
+    const hits = perNest.flat().sort((a, b) => titleScore(b.title, q) - titleScore(a.title, q));
+    return c.json({
+      query: q,
+      count: hits.length,
+      nodes: hits.slice(0, limit)
+    });
+  });
   app.use("/runs/*", flexAuthMiddleware);
   app.route("/runs", runDetailRoutes);
   app.route("/hooks", hookFireRoutes);
@@ -11735,7 +12340,8 @@ function createApp() {
       c.set("nestPermission", "owner");
       return next();
     }
-    const permission = await resolveNestPermission(nestId, userId);
+    const access = await resolveNestAccess(nestId, userId);
+    const permission = access.permission;
     const isReadQuery = parts.length === 2 && ["context", "query", "search", "export"].includes(parts[1]);
     let grantRole = null;
     let grantNestVisible = false;
@@ -11748,11 +12354,13 @@ function createApp() {
         }
         grantRole = await resolveNodeGrant(nestId, userId, targetTail);
       } else if (parts.length === 1 && c.req.method === "GET") {
-        grantNestVisible = await hasAnyGrant(nestId, userId);
+        grantNestVisible = access.hasGrant;
       } else if (parts[1] === "nodes" && parts.length === 2 && c.req.method === "GET") {
-        grantNestVisible = await hasAnyGrant(nestId, userId);
+        grantNestVisible = access.hasGrant;
       } else if (isReadQuery) {
-        grantNestVisible = await hasAnyGrant(nestId, userId);
+        grantNestVisible = access.hasGrant;
+      } else if (parts[1] === "definitions" && parts.length === 2 && c.req.method === "GET") {
+        grantNestVisible = access.hasGrant;
       }
       if (!grantRole && !grantNestVisible) {
         return deny(404, "Nest not found", {
@@ -11765,7 +12373,7 @@ function createApp() {
     const isStewardActionPath = path.includes("/approve") || path.includes("/reject") || path.includes("/submit-review") || path.includes("/cancel-review");
     const isAnnotationAction = /\/annotations$/.test(path) || /\/annotations\/[^/]+\/(comments|resolve|reopen)$/.test(path);
     const isCommentAction = /\/comments$/.test(path) || /\/comments\/[^/]+\/resolve$/.test(path);
-    const isDeletionRequestAction = /\/request-deletion$/.test(path);
+    const isDeletionRequestAction = /\/request-deletion$/.test(path) || /\/deletion-requests\/[^/]+\/withdraw$/.test(path);
     const isStewardRoster = path.includes("/stewards") && !path.includes("/nodes/");
     if (isStewardRoster && permission !== "owner" && permission !== "admin") {
       return c.json(
@@ -11877,6 +12485,7 @@ function createApp() {
   nestsApp.route("/:nestId/assets", assetRoutes);
   nestsApp.route("/:nestId/mcp", mcpRoutes);
   app.route("/nests", nestsApp);
+  app.all("/.well-known/*", (c) => c.json({ error: "Not found" }, 404));
   app.use(
     "/assets/*",
     serveStatic({
@@ -11884,14 +12493,20 @@ function createApp() {
       onFound: (_p, c) => c.header("Cache-Control", "public, max-age=31536000, immutable")
     })
   );
+  const isDocumentNavigation = (c) => c.req.header("Sec-Fetch-Mode") === "navigate" || (c.req.header("Accept") || "").includes("text/html");
   app.get(
     "*",
+    async (c, next) => {
+      if (isDocumentNavigation(c)) return next();
+      return c.json({ error: "Not found" }, 404);
+    },
     serveStatic({
       root: UI_DIR_REL,
       path: "index.html",
       onFound: (_p, c) => c.header("Cache-Control", "no-cache")
     })
   );
+  app.notFound((c) => c.json({ error: "Not found" }, 404));
   app.onError((err, c) => {
     if (err instanceof AppError) {
       return c.json({ error: err.message }, err.statusCode);
@@ -12327,6 +12942,7 @@ async function main() {
     POST /nests/:id/query        Selector query
     POST /nests/:id/context      One-call context retrieval
     GET  /nests/:id/search?q=    Full-text search
+    GET  /search?q=              Search every nest you can see
     POST /nests/:id/publish      Bulk publish
     POST /nests/:id/mcp          MCP endpoint
     GET  /health                 Health check