@promptowl/contextnest-community 1.14.0 → 1.16.1

package/dist/index.js

@@ -4,36 +4,42 @@ import {
   approve,
   canReadNode,
   cancelReview,
+  declineDeletion,
+  deletionTargetTitle,
   dispatchEvent,
+  dropDeletionRequest,
   edgeTypeRoutes,
   edgeTypeToResponse,
   envRoutes,
   envValues,
   filterAccessible,
+  getDeletionRequest,
+  getLatestDeletionRequest,
   getPendingReview,
   getReviewHistory,
   getReviewQueue,
   isSafeConnectorUrl,
+  listDeletionRequests,
   listNotifications,
   listWatchers,
   markNotificationsRead,
   nodeWriteKey,
+  notifyDeletionResolved,
   notifyNestEvent,
   notifyNestInvite,
   parseConditionSchema,
   reject,
   removeWatcher,
   repointPendingReview,
+  requestDeletion,
   requireWorkflowPlane,
   resolveCallerEmail,
   safeJson,
-  safePublishDocument,
   seedDefaultEdgeTypes,
   sendTestNotification,
-  stripUndefinedDeep,
   submitForReview,
   withNodeWriteLock
-} from "./chunk-MZ4IR5KH.js";
+} from "./chunk-QJVRZT6M.js";
 import {
   createGrant,
   deleteGrant,
@@ -42,7 +48,7 @@ import {
   listGrants,
   listUserGrants,
   resolveNodeGrant
-} from "./chunk-IHGPZ6NY.js";
+} from "./chunk-OTGZQZKK.js";
 import {
   generateApiKey,
   getKeyPrefix,
@@ -55,39 +61,56 @@ import {
   checkConflict,
   createVersion,
   getApprovedVersion,
+  getApprovedVersions,
   getCurrentVersion,
   getDisplayStatus,
+  getTrackedNodeIds,
   getVersions,
+  listMyDrafts,
   setApprovedVersion,
   upsertVersion
-} from "./chunk-JP67WXLA.js";
+} from "./chunk-D6HICFVW.js";
 import {
-  addMember,
-  buildTitleMap,
   canCreateInNest,
   canManageStewards,
   canUserAccess,
   canUserApprove,
   canUserEdit,
-  createNest,
   createStewardRecord,
+  getCollaboratorRole,
+  getStewardRolesForUser,
+  getStewardsForNest,
+  getStewardsForUser,
+  listStewards,
+  removeSteward,
+  resolveGrantRoles,
+  resolveStewardsForNode,
+  resolveStewardsWithFallback,
+  resolveUserRoles,
+  syncFromConfig,
+  updateSteward
+} from "./chunk-CLKZZZS2.js";
+import {
+  addMember,
+  buildTitleMap,
+  canApproveWith,
+  createNest,
   createTeam,
   deleteNest,
   deleteTeam,
   disableStewardshipAndWipeGovernance,
   docLink,
+  engineApi,
   engineCache,
   findTeamByExternalId,
+  folderForNode,
   getAccessConfig,
-  getCollaboratorRole,
   getCurrentLicense,
   getNest,
-  getStewardRolesForUser,
-  getStewardsForNest,
-  getStewardsForUser,
   getSuspensionReason,
   getTeam,
   importNest,
+  insertOrIgnore,
   installLicenseKey,
   isConfigSuperAdmin,
   isLicenseAdminEmail,
@@ -101,7 +124,6 @@ import {
   listNests,
   listPublicNests,
   listSharedNests,
-  listStewards,
   listTeamsForUser,
   listVisibleNests,
   loadAccessConfig,
@@ -109,36 +131,38 @@ import {
   loadServerSettings,
   nestAllowsSelfApprove,
   nestName,
+  nestPrimeTags,
+  nestReviewsPrimeOnly,
   nestStorageRoot,
+  normalizeTag,
+  nowExpr,
+  opContext,
   permissionLevel,
   persistSetting,
   removeMember,
-  removeSteward,
+  removeNodeFromTagIndex,
   renameNest,
   renameTeam,
   replaceTeamRoster,
-  resolveGrantRoles,
   resolveMemberIdentity,
   resolveNestPath,
   resolveNestPermission,
-  resolveStewardsForNode,
-  resolveStewardsWithFallback,
-  resolveUserRoles,
   sendEmailToRecipient,
   setAllowSelfApprove,
+  setPrimeOnlyReview,
+  setPrimeTags,
   setStewardshipEnabled,
   shareTeamWithNest,
   startLicenseSafetyPoll,
   startTelemetryLoop,
-  syncFromConfig,
+  syncNodeTags,
   trackEvent,
   uniqueNestName,
   unshareTeamFromNest,
   updateMemberRole,
-  updateSteward,
   validateLicense,
   verifySmtp
-} from "./chunk-KPK656BH.js";
+} from "./chunk-L7UCMGWZ.js";
 import {
   AppError,
   ConflictError,
@@ -148,24 +172,20 @@ import {
   UnauthorizedError,
   ValidationError
 } from "./chunk-GUNJTORH.js";
-import {
-  normalizeEmail
-} from "./chunk-FRQJWGN3.js";
-import {
-  insertOrIgnore,
-  nowExpr
-} from "./chunk-XQ46F76G.js";
 import {
   config,
   getDb,
   initDb,
   isEmailListish,
   isEmailish
-} from "./chunk-I5KYGMIT.js";
+} from "./chunk-JMJLNEXE.js";
 import {
   ANON_EMAIL,
   ANON_USER_ID
 } from "./chunk-SLTQACJW.js";
+import {
+  normalizeEmail
+} from "./chunk-FRQJWGN3.js";
 
 // src/index.ts
 import { serve } from "@hono/node-server";
@@ -176,6 +196,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";
@@ -393,6 +436,9 @@ function sweepStale(maxAgeMs = 10 * 6e4) {
 
 // src/auth/sso-token.ts
 import { createHmac, timingSafeEqual } from "crypto";
+function isValidTicketSub(sub) {
+  return /^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(sub) && sub.length <= 254;
+}
 function b64urlToBuffer(input) {
   const pad = input.length % 4 === 0 ? "" : "=".repeat(4 - input.length % 4);
   return Buffer.from(input.replace(/-/g, "+").replace(/_/g, "/") + pad, "base64");
@@ -1215,6 +1261,7 @@ authRoutes.get("/sso", async (c) => {
   } catch {
     return ssoError("invalid_ticket");
   }
+  if ((claims.scope || "") === "mcp") return ssoError("invalid_ticket");
   const expectedAud = config.PUBLIC_BASE_URL;
   if (!expectedAud && !warnedMissingSsoAudience) {
     warnedMissingSsoAudience = true;
@@ -1227,7 +1274,7 @@ authRoutes.get("/sso", async (c) => {
     if (aud !== expectedAud) return ssoError("bad_audience");
   }
   const sub = (claims.sub || "").trim();
-  if (!/^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(sub) || sub.length > 254) {
+  if (!isValidTicketSub(sub)) {
     return ssoError("invalid_ticket");
   }
   if (!claims.jti) return ssoError("invalid_ticket");
@@ -1557,48 +1604,58 @@ 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
+  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/tag-index-service.ts
-function normalizeTag(raw) {
-  return raw.trim().replace(/^#+/, "").toLowerCase();
+// src/governance/safe-publish.ts
+import {
+  publishDocument,
+  serializeDocument
+} from "@promptowl/contextnest-engine";
+function serializeNodeSafe(node) {
+  return serializeDocument({
+    ...node,
+    frontmatter: stripUndefinedDeep(node.frontmatter)
+  });
 }
-async function syncNodeTags(nestId, nodeId, tags) {
-  const db = getDb();
-  const normalized = Array.from(
-    new Set(
-      tags.filter((t) => typeof t === "string").map(normalizeTag).filter(Boolean)
-    )
-  );
-  const insertSql = insertOrIgnore(
-    db,
-    "INSERT INTO node_tag_index (nest_id, node_id, tag_name) VALUES (?, ?, ?)"
-  );
-  await db.transaction(async (tx) => {
-    await tx.run(
-      "DELETE FROM node_tag_index WHERE nest_id = ? AND node_id = ?",
-      [nestId, nodeId]
-    );
-    for (const tag of normalized) {
-      await tx.run(insertSql, [nestId, nodeId, tag]);
+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;
 }
-async function removeNodeFromTagIndex(nestId, nodeId) {
-  const db = getDb();
-  await db.run(
-    "DELETE FROM node_tag_index WHERE nest_id = ? AND node_id = ?",
-    [nestId, nodeId]
-  );
+
+// src/governance/prime-service.ts
+async function isPrimeDocument(nestId, tags, metadata) {
+  const flag = documentPrimeFlag(metadata);
+  if (flag !== void 0) return flag;
+  const primeTags = await nestPrimeTags(nestId);
+  if (!primeTags.length) return false;
+  const wanted = new Set(primeTags);
+  return (tags || []).some((t) => wanted.has(normalizeTag(String(t))));
+}
+function documentPrimeFlag(metadata) {
+  const raw = metadata?.prime;
+  if (typeof raw === "boolean") return raw;
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  return void 0;
 }
 
 // src/governance/external-edit-service.ts
@@ -1607,6 +1664,7 @@ import { join } from "path";
 import {
   detectDrift,
   stageSuggestion,
+  ChainEventLog,
   approveSuggestion,
   rejectSuggestion,
   listSuggestions,
@@ -1689,7 +1747,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))
@@ -1760,6 +1819,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-V6K5SZ3P.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;
@@ -1781,33 +1902,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-FGL47APL.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);
@@ -1820,6 +1929,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) {
@@ -1831,7 +1941,7 @@ async function rejectExternalEdit(input) {
       err
     );
   }
-  return result;
+  return { ...result, historyRecorded };
 }
 var scannerTimer = null;
 async function scanAllNests() {
@@ -1865,9 +1975,33 @@ async function userIdFromEmail(email) {
   return row?.id ?? ANON_USER_ID;
 }
 var normalizeTag2 = (t) => t.startsWith("#") ? t : `#${t}`;
+var MAX_TITLE_LENGTH = 120;
+function assertTitleLength(title) {
+  if (title.length > MAX_TITLE_LENGTH) {
+    throw new ValidationError(
+      `title must be at most ${MAX_TITLE_LENGTH} characters`
+    );
+  }
+}
+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");
   }
@@ -1878,7 +2012,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 {
@@ -1895,6 +2028,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);
 }
@@ -1928,7 +2067,8 @@ function toNodeResponse(node) {
     pendingChange: node.pendingChange ?? void 0,
     // Same YAML-coercion rule as title above: `schedule: 123` parses as a
     // number — normalize to string at the API boundary.
-    schedule: fm.metadata?.schedule != null ? String(fm.metadata.schedule) : void 0
+    schedule: fm.metadata?.schedule != null ? String(fm.metadata.schedule) : void 0,
+    prime: documentPrimeFlag(fm.metadata)
   };
 }
 async function resolveAuthorship(nestId, nodes) {
@@ -1984,28 +2124,89 @@ 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"
+    );
+  }
+  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)
     );
-    documents = documents.filter((n) => wanted.has(n.frontmatter.type));
+  } 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}`);
   }
-  if (filters.tag) {
-    const tag = normalizeTag2(filters.tag);
-    documents = documents.filter(
-      (n) => (n.frontmatter.tags || []).includes(tag)
+  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);
-  let accessible = await filterAccessible(nestId, userId, userEmail, documents);
+  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
+  );
   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;
+    accessible = grants.length ? nodes.filter((d) => grantCoversNode(grants, d.id)) : accessible;
   }
-  const publicReader = await isPublicReader(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) => ({
@@ -2021,8 +2222,8 @@ async function listNodesForCaller(nestId, userId, filters = {}) {
         r.author = people.author;
         r.collaborators = people.collaborators;
       }
-      if (publicReader) {
-        const approved = await getApprovedVersion(nestId, doc.id);
+      if (approvedVersions) {
+        const approved = approvedVersions.get(doc.id);
         if (approved != null) {
           try {
             const raw = await versionManager.reconstructVersion(
@@ -2059,7 +2260,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);
@@ -2069,20 +2270,32 @@ async function actorAutoPublishes(nestId, userEmail) {
   const roles = await resolveUserRoles(nestId, userEmail);
   return roles.includes("owner") || roles.includes("admin");
 }
+async function assertMayFlagPrime(nestId, userEmail) {
+  const roles = await resolveUserRoles(nestId, userEmail);
+  if (!roles.includes("owner") && !roles.includes("admin")) {
+    throw new ForbiddenError(
+      "Only the nest owner or an admin can change a document's prime flag."
+    );
+  }
+}
+async function autoPublishReason(nestId, userEmail, doc) {
+  if (!await isStewardshipEnabled(nestId)) return "no stewards configured";
+  if (await isPrimeDocument(nestId, doc.tags, doc.metadata)) return null;
+  if (await nestReviewsPrimeOnly(nestId)) {
+    return "prime-only review, document is not prime";
+  }
+  return await actorAutoPublishes(nestId, userEmail) ? "owner/admin self-approve" : null;
+}
 async function createNode(nestId, input, userEmail) {
   const { storage, versions: versionManager } = await engineCache.get(nestId);
-  const slug = slugify(input.title);
+  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 ?? "");
-    if ([...folderSegments, slug].some((seg) => seg.length > 100)) {
-      throw new ValidationError(
-        "each folder or title segment must be at most 100 characters"
-      );
-    }
     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) {
@@ -2098,72 +2311,104 @@ async function createNode(nestId, input, userEmail) {
       )})`
     );
   }
-  const deptTag = await departmentTagFor(userEmail);
-  if (deptTag && !tags.some((t) => t.toLowerCase() === deptTag)) {
-    tags.push(deptTag);
-  }
-  const hasStewards = await isStewardshipEnabled(nestId);
-  const autoPublish = !hasStewards || await actorAutoPublishes(nestId, userEmail);
-  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: {
-        owners: ["*"],
-        scope: input.scope || "team",
-        ...input.schedule ? { schedule: input.schedule } : {}
-      }
-    },
-    body: input.content,
-    rawContent: ""
-  };
-  await storage.writeDocument(id, serializeDocument(node));
-  await syncNodeTags(nestId, id, tags);
-  let savedVersion = 1;
-  if (!autoPublish) {
+  return withNodeWriteLock(nodeWriteKey(nestId, id), async () => {
+    let occupied = false;
     try {
-      await versionManager.createVersion(node, userEmail);
+      await storage.readDocument(id);
+      occupied = true;
     } catch (err) {
-      console.error("VersionManager.createVersion failed (node create)", err);
+      if (!(err instanceof DocumentNotFoundError)) throw err;
     }
-    await createVersion({
-      nestId,
-      nodeId: id,
-      version: 1,
-      content: input.content,
-      author: userEmail,
-      status: "draft",
-      tags
+    if (occupied) {
+      throw new ConflictError(
+        `A document already exists at ${id}. Update it, or create this one under a different folder or title.`
+      );
+    }
+    const db = getDb();
+    const orphan = await db.get(
+      "SELECT 1 AS present FROM node_versions WHERE nest_id = ? AND node_id = ? LIMIT 1",
+      [nestId, id]
+    );
+    if (orphan) {
+      console.warn(
+        `[nodes] clearing orphaned rows for ${id} \u2014 version history exists but no document does`
+      );
+      await db.transaction(async (tx) => {
+        await purgeNodeKeyedRows(tx, nestId, id);
+      });
+    }
+    const deptTag = await departmentTagFor(userEmail);
+    if (deptTag && !tags.some((t) => t.toLowerCase() === deptTag)) {
+      tags.push(deptTag);
+    }
+    if (input.prime !== void 0) await assertMayFlagPrime(nestId, userEmail);
+    const metadata = {
+      owners: ["*"],
+      scope: input.scope || "team",
+      ...input.schedule ? { schedule: input.schedule } : {},
+      ...input.prime === void 0 ? {} : { prime: input.prime }
+    };
+    const publishReason = await autoPublishReason(nestId, userEmail, {
+      tags,
+      metadata
     });
-  } else {
+    const publishNote = publishReason === null ? void 0 : `Auto-published on create (${publishReason})`;
+    let published = publishReason !== null;
     try {
-      const result = await safePublishDocument(storage, id, {
-        editedBy: userEmail,
-        note: hasStewards ? "Auto-published on create (owner/admin self-approve)" : "Auto-published on create (no stewards configured)"
-      });
-      savedVersion = result.node.frontmatter.version || 1;
+      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 (published) {
+      savedVersion = node.frontmatter.version || 1;
       await createVersion({
         nestId,
         nodeId: id,
         version: savedVersion,
-        content: result.node.body || "",
+        content: node.body || "",
         author: userEmail,
         status: "published",
-        tags
+        tags,
+        changeNote: publishNote
       });
       await setApprovedVersion(nestId, id, savedVersion, userEmail);
-      node = result.node;
-    } catch (err) {
-      console.error("publishDocument failed (node create auto-publish)", err);
+    } else {
+      if (publishReason === null) {
+        try {
+          await versionManager.createVersion(node, userEmail);
+        } catch (err) {
+          console.error("VersionManager.createVersion failed (node create)", err);
+        }
+      }
       await createVersion({
         nestId,
         nodeId: id,
@@ -2174,140 +2419,102 @@ async function createNode(nestId, input, userEmail) {
         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;
+    await trackEvent("node.create", { nestId, nodeId: id });
+    return { node, version: savedVersion };
+  });
 }
-async function resetImportedDocForPublish(storage, nestId, nodeId) {
-  const versionsDir = join2(
-    resolveNestPath(nestId),
-    dirname(nodeId),
-    ".versions",
-    basename(nodeId)
+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)
   );
-  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, serializeDocument({ ...node, frontmatter: fm }));
+  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 registerImportedDocuments(nestId, userEmail, onProgress) {
-  const { storage } = await engineCache.get(nestId);
-  let docs;
+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 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: d.id,
+      version: d.version,
+      content: d.content,
+      author: userEmail,
+      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 (d.status === "published") {
+      await setApprovedVersion(nestId, d.id, d.version, userEmail);
+    } else {
+      await alignOnDiskStatus(nestId, d.id, d.status);
     }
-    const title = doc.frontmatter?.title ?? (nodeId.split("/").pop() || nodeId);
-    doc = { ...doc, frontmatter: { ...doc.frontmatter, title, author: userEmail } };
-    try {
-      await storage.writeDocument(nodeId, serializeDocument(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
-        );
-      }
-    }
-    await createVersion({
-      nestId,
-      nodeId,
-      version,
-      content,
-      author: userEmail,
-      status: published ? "published" : "draft",
-      changeNote: "Imported from existing folder",
-      tags
-    });
-    if (published) {
-      await setApprovedVersion(nestId, nodeId, version, userEmail);
-    }
-    await syncNodeTags(nestId, nodeId, tags);
-    registered++;
-  }
-  console.log(
-    `[import] register done: registered=${registered} alreadyTracked=${alreadyTracked} keptUnpublished=${keptUnpublished} publishRecovered=${publishRecovered} publishFailed=${publishFailed} tookMs=${Date.now() - startedAt}`
-  );
-  await trackEvent("nest.import.documents", { nestId, registered });
-  return registered;
-}
-async function updateNode(nestId, nodeId, patch, userEmail) {
-  return withNodeWriteLock(nodeWriteKey(nestId, nodeId), async () => {
+    await syncNodeTags(nestId, d.id, tags);
+  }
+  const published = docs.filter((d) => d.status === "published").length;
+  console.log(
+    `[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}`
+  );
+  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 () => {
     try {
       const { storage, versions: versionManager } = await engineCache.get(
         nestId
@@ -2318,30 +2525,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)) {
@@ -2355,10 +2575,25 @@ 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);
+        const metadata = { ...node.frontmatter.metadata };
+        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 autoPublish = !hasStewards || await actorAutoPublishes(nestId, userEmail);
       const currentTags = node.frontmatter.tags || [];
+      const publishReason = await autoPublishReason(nestId, userEmail, {
+        tags: currentTags,
+        metadata: node.frontmatter.metadata
+      });
       const pendingReview = hasStewards ? await getPendingReview(nestId, nodeId) : null;
       const isAuthorEditingOwnReview = !!pendingReview && pendingReview.requestedBy.toLowerCase() === userEmail.toLowerCase();
       if (pendingReview && !isAuthorEditingOwnReview) {
@@ -2367,22 +2602,15 @@ async function updateNode(nestId, nodeId, patch, userEmail) {
         );
       }
       let responseVersion;
-      if (!autoPublish || isAuthorEditingOwnReview) {
+      if (publishReason === null || isAuthorEditingOwnReview) {
         const currentVersion = await getCurrentVersion(nestId, nodeId);
-        const newVersion = currentVersion + 1;
-        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));
+        const newVersion = await versionManager.nextVersion(nodeId, currentVersion);
+        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, {
@@ -2410,25 +2638,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: patch.changeNote || (hasStewards ? "Auto-published on edit (owner/admin self-approve)" : "Auto-published on edit (no stewards)")
-          });
-          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)",
@@ -2436,6 +2654,8 @@ async function updateNode(nestId, nodeId, patch, userEmail) {
           );
           throw err;
         }
+        node = await storage.readDocument(nodeId);
+        await syncNodeTags(nestId, nodeId, currentTags);
         await upsertVersion({
           nestId,
           nodeId,
@@ -2444,7 +2664,7 @@ async function updateNode(nestId, nodeId, patch, userEmail) {
           author: userEmail,
           status: "published",
           tags: currentTags,
-          changeNote: patch.changeNote
+          changeNote: publishNote
         });
         await setApprovedVersion(
           nestId,
@@ -2464,9 +2684,69 @@ async function updateNode(nestId, nodeId, patch, userEmail) {
     }
   });
 }
+async function assertNotReviewLocked(nestId, nodeId, userEmail, action) {
+  if (!await isStewardshipEnabled(nestId)) return;
+  if (!await getPendingReview(nestId, nodeId)) return;
+  if (canApproveWith(await resolveUserRoles(nestId, userEmail, { nodeId }))) return;
+  throw new LockedError(
+    `This document is awaiting steward review and is locked. Approve or reject the pending review before ${action}, or ask a reviewer to.`
+  );
+}
 function derivedIdOf(sourceNodeId) {
   return `nodes/${sourceNodeId.replace(/^nodes\//, "")}--annotations`;
 }
+var NODE_KEYED_TABLES = [
+  ["node_versions", "node_id"],
+  ["review_requests", "node_id"],
+  ["deletion_requests", "node_id"],
+  ["approved_versions", "node_id"],
+  ["annotation_threads", "node_id"],
+  ["comments", "node_id"],
+  ["node_tag_index", "node_id"],
+  ["watchers", "node_id"],
+  ["schedules", "agent_node"],
+  // A live capability token bound to one agent node — deleting the agent must
+  // revoke it, or a later node at that id answers the old webhook.
+  ["trigger_hooks", "agent_node"],
+  ["edges", "from_node"],
+  ["edges", "to_node"]
+];
+async function purgeNodeKeyedRows(tx, nestId, nodeId) {
+  for (const [table, column] of NODE_KEYED_TABLES) {
+    await tx.run(`DELETE FROM ${table} WHERE nest_id = ? AND ${column} = ?`, [
+      nestId,
+      nodeId
+    ]);
+  }
+  await tx.run(
+    `DELETE FROM stewards
+     WHERE nest_id = ? AND scope = 'document' AND node_pattern = ?`,
+    [nestId, nodeId]
+  );
+  await tx.run(
+    `DELETE FROM grants
+     WHERE nest_id = ? AND target_type = 'document' AND target = ?`,
+    [nestId, nodeId]
+  );
+}
+async function rewriteNodeKeyedRows(tx, nestId, oldId, newId) {
+  for (const [table, column] of NODE_KEYED_TABLES) {
+    await tx.run(
+      `UPDATE ${table} SET ${column} = ? WHERE nest_id = ? AND ${column} = ?`,
+      [newId, nestId, oldId]
+    );
+  }
+  await tx.run(
+    `UPDATE stewards SET node_pattern = ?
+     WHERE nest_id = ? AND scope = 'document' AND node_pattern = ?`,
+    [newId, nestId, oldId]
+  );
+  await tx.run(
+    `UPDATE grants SET target = ?
+     WHERE nest_id = ? AND target_type = 'document' AND target = ?`,
+    [newId, nestId, oldId]
+  );
+}
 async function moveNode(nestId, nodeId, folder, userEmail) {
   const { storage } = await engineCache.get(nestId);
   let node;
@@ -2475,108 +2755,138 @@ async function moveNode(nestId, nodeId, folder, userEmail) {
   } catch {
     throw new NotFoundError(`Node not found: ${nodeId}`);
   }
-  if (await isStewardshipEnabled(nestId) && await getPendingReview(nestId, nodeId)) {
-    throw new LockedError(
-      "This document is awaiting steward review and is locked. Approve or reject the pending review before moving."
-    );
-  }
+  await assertNotReviewLocked(nestId, nodeId, userEmail, "moving");
   const leaf = nodeId.split("/").pop();
   const segments = folderToSegments(folder);
   const newId = segments.length > 0 ? `nodes/${segments.join("/")}/${leaf}` : `nodes/${leaf}`;
   if (newId === nodeId) return { node, previousId: nodeId };
-  try {
-    await storage.readDocument(newId);
-    throw new ConflictError(
-      `A document already exists at that location: ${newId}`
-    );
-  } catch (err) {
-    if (err instanceof ConflictError) throw err;
-  }
-  const moved = {
-    ...node,
-    id: newId,
-    frontmatter: {
-      ...node.frontmatter,
-      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  return withNodeWriteLock(nodeWriteKey(nestId, newId), async () => {
+    try {
+      await storage.readDocument(newId);
+      throw new ConflictError(
+        `A document already exists at that location: ${newId}`
+      );
+    } catch (err) {
+      if (err instanceof ConflictError) throw err;
+      if (!(err instanceof DocumentNotFoundError)) throw err;
     }
-  };
-  await storage.writeDocument(newId, serializeDocument(moved));
-  try {
-    const nestPath = resolveNestPath(nestId);
-    const oldChain = join2(nestPath, dirname(nodeId), ".versions", leaf);
-    const newChain = join2(nestPath, dirname(newId), ".versions", leaf);
-    if (oldChain !== newChain) {
-      await mkdir(dirname(newChain), { recursive: true });
-      await rename(oldChain, newChain);
+    const moved = {
+      ...node,
+      id: newId,
+      frontmatter: {
+        ...node.frontmatter,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+    await storage.writeDocument(newId, serializeNodeSafe(moved));
+    try {
+      const nestPath = resolveNestPath(nestId);
+      const oldChain = join2(nestPath, dirname(nodeId), ".versions", leaf);
+      const newChain = join2(nestPath, dirname(newId), ".versions", leaf);
+      if (oldChain !== newChain) {
+        await mkdir(dirname(newChain), { recursive: true });
+        await rename(oldChain, newChain);
+      }
+    } catch {
     }
-  } catch {
-  }
-  await storage.deleteDocument(nodeId);
-  const oldDerived = derivedIdOf(nodeId);
-  const newDerived = derivedIdOf(newId);
-  const db = getDb();
-  await db.transaction(async (tx) => {
-    for (const [table, column] of [
-      ["node_versions", "node_id"],
-      ["review_requests", "node_id"],
-      ["approved_versions", "node_id"],
-      ["annotation_threads", "node_id"],
-      ["comments", "node_id"],
-      ["node_tag_index", "node_id"]
-    ]) {
+    await storage.deleteDocument(nodeId);
+    const oldDerived = derivedIdOf(nodeId);
+    const newDerived = derivedIdOf(newId);
+    const db = getDb();
+    await db.transaction(async (tx) => {
+      await rewriteNodeKeyedRows(tx, nestId, nodeId, newId);
+      await rewriteNodeKeyedRows(tx, nestId, oldDerived, newDerived);
       await tx.run(
-        `UPDATE ${table} SET ${column} = ? WHERE nest_id = ? AND ${column} = ?`,
+        "UPDATE runs SET agent_node = ? WHERE nest_id = ? AND agent_node = ?",
         [newId, nestId, nodeId]
       );
       await tx.run(
-        `UPDATE ${table} SET ${column} = ? WHERE nest_id = ? AND ${column} = ?`,
-        [newDerived, nestId, oldDerived]
+        `UPDATE run_steps SET node_id = ?
+         WHERE node_id = ? AND run_id IN (SELECT id FROM runs WHERE nest_id = ?)`,
+        [newId, nodeId, nestId]
+      );
+    });
+    try {
+      const derivedDoc = await storage.readDocument(oldDerived);
+      await storage.writeDocument(
+        newDerived,
+        serializeNodeSafe({ ...derivedDoc, id: newDerived })
       );
+      await storage.deleteDocument(oldDerived);
+    } catch {
     }
-    await tx.run(
-      `UPDATE stewards SET node_pattern = ?
-       WHERE nest_id = ? AND scope = 'document' AND node_pattern = ?`,
-      [newId, nestId, nodeId]
-    );
-    await tx.run(
-      `UPDATE grants SET target = ?
-       WHERE nest_id = ? AND target_type = 'document' AND target = ?`,
-      [newId, nestId, nodeId]
-    );
-    await tx.run(
-      "UPDATE edges SET from_node = ? WHERE nest_id = ? AND from_node = ?",
-      [newId, nestId, nodeId]
-    );
-    await tx.run(
-      "UPDATE edges SET to_node = ? WHERE nest_id = ? AND to_node = ?",
-      [newId, nestId, nodeId]
+    await trackEvent("node.move", { nestId, nodeId, newId });
+    return { node: moved, previousId: nodeId };
+  });
+}
+async function deleteNode(nestId, nodeId, userEmail) {
+  const { storage } = await engineCache.get(nestId);
+  await assertNotReviewLocked(nestId, nodeId, userEmail, "deleting");
+  try {
+    await engineApi.run(
+      "context_delete",
+      { id: nodeId },
+      await opContext(nestId, userEmail)
     );
-    await tx.run(
-      "UPDATE runs SET agent_node = ? WHERE nest_id = ? AND agent_node = ?",
-      [newId, nestId, nodeId]
+  } catch {
+    throw new NotFoundError(`Node not found: ${nodeId}`);
+  }
+  await removeNodeFromTagIndex(nestId, nodeId);
+  const derivedId = derivedIdOf(nodeId);
+  try {
+    await engineApi.run(
+      "context_delete",
+      { id: derivedId },
+      await opContext(nestId, userEmail)
     );
+    await removeNodeFromTagIndex(nestId, derivedId);
+  } catch {
+  }
+  const db = getDb();
+  await db.transaction(async (tx) => {
+    await purgeNodeKeyedRows(tx, nestId, nodeId);
+    await purgeNodeKeyedRows(tx, nestId, derivedId);
     await tx.run(
-      `UPDATE run_steps SET node_id = ?
-       WHERE node_id = ? AND run_id IN (SELECT id FROM runs WHERE nest_id = ?)`,
-      [newId, nodeId, nestId]
+      `INSERT INTO node_deletions (nest_id, node_id, deleted_by, deleted_at)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT(nest_id, node_id) DO UPDATE
+         SET deleted_by = excluded.deleted_by, deleted_at = excluded.deleted_at`,
+      [nestId, nodeId, userEmail, (/* @__PURE__ */ new Date()).toISOString()]
     );
   });
-  try {
-    const derivedDoc = await storage.readDocument(oldDerived);
-    await storage.writeDocument(
-      newDerived,
-      serializeDocument({ ...derivedDoc, id: newDerived })
-    );
-    await storage.deleteDocument(oldDerived);
-  } catch {
+  await trackEvent("node.delete", { nestId, nodeId });
+}
+async function deleteFolder(nestId, folder, userEmail) {
+  const segments = folderToSegments(folder);
+  if (segments.length === 0) {
+    throw new ValidationError("folder is required");
+  }
+  const rel = segments.join("/");
+  const { storage } = await engineCache.get(nestId);
+  const docs = await storage.discoverDocuments();
+  const targets = docs.map((d) => d.id).filter((id) => isIdUnderFolder(id, rel));
+  if (targets.length === 0) {
+    throw new NotFoundError(`No documents found under folder: ${folder}`);
+  }
+  const deleted = [];
+  for (const id of targets) {
+    try {
+      await deleteNode(nestId, id, userEmail);
+      deleted.push(id);
+    } catch (err) {
+      const detail = deleted.length > 0 ? ` (${deleted.length} of ${targets.length} already deleted)` : "";
+      throw new Error(
+        `Failed to delete "${id}"${detail}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
   }
-  await trackEvent("node.move", { nestId, nodeId, newId });
-  return { node: moved, previousId: nodeId };
+  return deleted;
 }
 
 // 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());
@@ -2744,23 +3054,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);
@@ -2776,7 +3094,7 @@ 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}`);
 }
 
@@ -2883,42 +3201,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");
@@ -2958,7 +3284,7 @@ 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) => {
@@ -3023,7 +3349,9 @@ nestRoutes.get("/:nestId/settings", async (c) => {
   }
   return c.json({
     stewardship_enabled: await isStewardshipEnabled(nestId),
-    allow_self_approve: await nestAllowsSelfApprove(nestId)
+    allow_self_approve: await nestAllowsSelfApprove(nestId),
+    prime_only_review: await nestReviewsPrimeOnly(nestId),
+    prime_tags: await nestPrimeTags(nestId)
   });
 });
 nestRoutes.patch("/:nestId/settings", async (c) => {
@@ -3059,9 +3387,20 @@ nestRoutes.patch("/:nestId/settings", async (c) => {
   if (typeof body.allow_self_approve === "boolean") {
     await setAllowSelfApprove(nestId, body.allow_self_approve);
   }
+  if (typeof body.prime_only_review === "boolean") {
+    await setPrimeOnlyReview(nestId, body.prime_only_review);
+  }
+  if (body.prime_tags !== void 0) {
+    await setPrimeTags(
+      nestId,
+      Array.isArray(body.prime_tags) ? body.prime_tags : [body.prime_tags]
+    );
+  }
   return c.json({
     stewardship_enabled: await isStewardshipEnabled(nestId),
     allow_self_approve: await nestAllowsSelfApprove(nestId),
+    prime_only_review: await nestReviewsPrimeOnly(nestId),
+    prime_tags: await nestPrimeTags(nestId),
     wiped
   });
 });
@@ -3662,27 +4001,33 @@ teamRoutes.delete("/:teamId/members/:userId", async (c) => {
   return c.json({ team });
 });
 
+// src/nodes/search.ts
+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));
+  });
+}
+function toSearchHit(node) {
+  return {
+    id: node.id,
+    title: node.frontmatter.title,
+    type: node.frontmatter.type || "document",
+    tags: node.frontmatter.tags || [],
+    snippet: (node.body || "").slice(0, 200).replace(/\n/g, " ")
+  };
+}
+
 // 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) {
@@ -3732,311 +4077,23 @@ ${m[1]}
 ` : "";
 }
 
-// src/annotations/service.ts
-import { v4 as uuid5 } from "uuid";
-
-// src/annotations/projection.ts
-var MAX_CONTEXT_CHARS = 250;
-var MAX_QUOTE_CHARS = 1e3;
-function clampAnchor(raw) {
-  if (!raw) return null;
-  const quote = (raw.quote ?? "").trim().slice(0, MAX_QUOTE_CHARS);
-  if (!quote) return null;
-  const before = (raw.before ?? "").slice(-MAX_CONTEXT_CHARS);
-  const after = (raw.after ?? "").slice(0, MAX_CONTEXT_CHARS);
-  const line = typeof raw.line === "number" && Number.isFinite(raw.line) && raw.line > 0 ? Math.floor(raw.line) : void 0;
-  return { quote, before, after, ...line !== void 0 ? { line } : {} };
-}
-function oneLine(s) {
-  return s.replace(/\s+/g, " ").replace(/--+>/g, "-\u2192").trim();
+// src/nodes/routes.ts
+var nodeRoutes = new Hono8();
+function nodeAsMarkdown(response, nodeId) {
+  return nodeToMarkdown({
+    id: nodeId,
+    title: response.title,
+    tags: response.tags,
+    status: response.status,
+    body: response.content
+  });
 }
-function renderAnchor(anchor) {
-  if (!anchor) {
-    return "<!-- anchor: whole-artifact -->";
-  }
-  const linePart = anchor.line !== void 0 ? `line ${anchor.line} \xB7 ` : "";
-  const context = `\u2026${oneLine(anchor.before)}\u3008${oneLine(anchor.quote)}\u3009${oneLine(
-    anchor.after
-  )}\u2026`;
-  return `<!-- anchor: ${linePart}quote "${oneLine(anchor.quote)}" \xB7 context ${context} -->`;
-}
-function statusHeading(thread) {
-  if (thread.status === "resolved") {
-    const who = thread.resolvedBy ? `${thread.resolvedBy}, ` : "";
-    const when = thread.resolvedAt ? `${thread.resolvedAt}` : "";
-    const meta = who || when ? ` (${who}${when})` : "";
-    return `\u2705 RESOLVED${meta}`;
-  }
-  return "\u{1F7E0} OPEN";
-}
-function snapshotLabel(v) {
-  return v == null ? "Unpinned" : `Snapshot v${v}`;
-}
-function orderThreads(threads) {
-  return [...threads].sort((a, b) => {
-    if (a.status !== b.status) return a.status === "open" ? -1 : 1;
-    return a.createdAt.localeCompare(b.createdAt);
-  });
-}
-function projectThreadsToMarkdown(artifactTitle, threads) {
-  const lines = [];
-  lines.push(`# ${artifactTitle} \u2014 Annotations`);
-  lines.push("");
-  lines.push(
-    "> Auto-generated from review comments, grouped by the artifact snapshot each was anchored to. **Open** threads are unresolved feedback for the next iteration; **resolved** threads were already addressed (don't re-break them)."
-  );
-  lines.push("");
-  if (threads.length === 0) {
-    lines.push("_No annotations yet._");
-    lines.push("");
-    return lines.join("\n");
-  }
-  const buckets2 = /* @__PURE__ */ new Map();
-  for (const t of threads) {
-    const key = t.snapshotVersion ?? null;
-    (buckets2.get(key) ?? buckets2.set(key, []).get(key)).push(t);
-  }
-  const keys = [...buckets2.keys()].sort((a, b) => {
-    if (a == null) return 1;
-    if (b == null) return -1;
-    return b - a;
-  });
-  for (const key of keys) {
-    lines.push(`## ${snapshotLabel(key)}`);
-    lines.push("");
-    for (const thread of orderThreads(buckets2.get(key))) {
-      lines.push(`### Thread \xB7 ${statusHeading(thread)}`);
-      lines.push(renderAnchor(thread.anchor));
-      for (const comment of thread.comments) {
-        lines.push(
-          `- **${comment.author}** \xB7 ${comment.createdAt} \u2014 ${comment.body}`
-        );
-      }
-      lines.push("");
-    }
-  }
-  return lines.join("\n");
-}
-
-// src/annotations/service.ts
-async function loadComments(threadId) {
-  const db = getDb();
-  const rows = await db.all(
-    "SELECT id, author, body, created_at FROM annotation_comments WHERE thread_id = ? ORDER BY created_at ASC, id ASC",
-    [threadId]
-  );
-  return rows.map((r) => ({
-    id: r.id,
-    author: r.author,
-    body: r.body,
-    createdAt: r.created_at
-  }));
-}
-async function rowToThread(row) {
-  let anchor = null;
-  if (row.anchor_json) {
-    try {
-      anchor = JSON.parse(row.anchor_json);
-    } catch {
-      anchor = null;
-    }
-  }
-  return {
-    id: row.id,
-    nestId: row.nest_id,
-    nodeId: row.node_id,
-    snapshotVersion: row.snapshot_version,
-    anchor,
-    status: row.status,
-    createdBy: row.created_by,
-    createdAt: row.created_at,
-    resolvedBy: row.resolved_by,
-    resolvedAt: row.resolved_at,
-    comments: await loadComments(row.id)
-  };
-}
-async function getThreadRow(threadId) {
-  return await getDb().get("SELECT * FROM annotation_threads WHERE id = ?", [threadId]);
-}
-async function countThreadsByNode(nestId) {
-  const rows = await getDb().all(
-    `SELECT node_id, CAST(COUNT(*) AS INTEGER) AS count, MAX(created_at) AS last_at
-         FROM annotation_threads
-        WHERE nest_id = ?
-        GROUP BY node_id`,
-    [nestId]
-  );
-  const out = {};
-  for (const r of rows) out[r.node_id] = { count: r.count, lastAt: r.last_at };
-  return out;
-}
-async function listThreads(nestId, nodeId) {
-  const rows = await getDb().all(
-    "SELECT * FROM annotation_threads WHERE nest_id = ? AND node_id = ? ORDER BY created_at ASC, id ASC",
-    [nestId, nodeId]
-  );
-  return Promise.all(rows.map(rowToThread));
-}
-async function createThread(nestId, nodeId, input, authorEmail) {
-  const body = (input.body ?? "").trim();
-  if (!body) {
-    throw new Error("comment body is required");
-  }
-  const db = getDb();
-  const id = uuid5();
-  const anchor = clampAnchor(input.anchor);
-  const snapshot = input.snapshotVersion ?? await getApprovedVersion(nestId, nodeId) ?? null;
-  await db.transaction(async (tx) => {
-    await tx.run(
-      `INSERT INTO annotation_threads
-         (id, nest_id, node_id, snapshot_version, anchor_json, status, created_by)
-       VALUES (?, ?, ?, ?, ?, 'open', ?)`,
-      [
-        id,
-        nestId,
-        nodeId,
-        snapshot,
-        anchor ? JSON.stringify(anchor) : null,
-        authorEmail
-      ]
-    );
-    await tx.run(
-      "INSERT INTO annotation_comments (id, thread_id, author, body) VALUES (?, ?, ?, ?)",
-      [uuid5(), id, authorEmail, body]
-    );
-  });
-  return rowToThread(await getThreadRow(id));
-}
-async function getScopedThreadRow(threadId, nestId, nodeId) {
-  const row = await getThreadRow(threadId);
-  if (!row || row.nest_id !== nestId || row.node_id !== nodeId) {
-    throw new NotFoundError(`Thread not found: ${threadId}`);
-  }
-  return row;
-}
-async function addComment(nestId, nodeId, threadId, authorEmail, body) {
-  const trimmed = (body ?? "").trim();
-  if (!trimmed) {
-    throw new Error("comment body is required");
-  }
-  await getScopedThreadRow(threadId, nestId, nodeId);
-  await getDb().run(
-    "INSERT INTO annotation_comments (id, thread_id, author, body) VALUES (?, ?, ?, ?)",
-    [uuid5(), threadId, authorEmail, trimmed]
-  );
-  return rowToThread(await getThreadRow(threadId));
-}
-async function setThreadStatus(nestId, nodeId, threadId, status, byEmail) {
-  await getScopedThreadRow(threadId, nestId, nodeId);
-  const db = getDb();
-  if (status === "resolved") {
-    await db.run(
-      `UPDATE annotation_threads SET status = 'resolved', resolved_by = ?, resolved_at = ${nowExpr(db)} WHERE id = ?`,
-      [byEmail, threadId]
-    );
-  } else {
-    await db.run(
-      "UPDATE annotation_threads SET status = 'open', resolved_by = NULL, resolved_at = NULL WHERE id = ?",
-      [threadId]
-    );
-  }
-  return rowToThread(await getThreadRow(threadId));
-}
-async function readArtifact(nestId, nodeId, version) {
-  const { storage, versions: versionManager } = await engineCache.get(nestId);
-  const target = version ?? await getApprovedVersion(nestId, nodeId) ?? null;
-  let title = nodeId;
-  let type = null;
-  let liveHtml = "";
-  let liveExists = true;
-  try {
-    const node = await storage.readDocument(nodeId);
-    title = node.frontmatter?.title || nodeId;
-    type = node.frontmatter?.type || null;
-    liveHtml = node.body || "";
-  } catch {
-    liveExists = false;
-  }
-  if (target != null) {
-    try {
-      const raw = await versionManager.reconstructVersion(nodeId, target);
-      return { title, html: bodyOnly(nodeId, raw), version: target, type };
-    } catch (err) {
-      console.warn(
-        `[annotations] reconstruct v${target} failed for ${nestId}/${nodeId}; falling back to live body:`,
-        err
-      );
-    }
-  }
-  if (!liveExists) {
-    throw new NotFoundError(`Artifact not found: ${nodeId}`);
-  }
-  return { title, html: liveHtml, version: target, type };
-}
-function derivedAnnotationsId(sourceNodeId) {
-  const base = sourceNodeId.replace(/^nodes\//, "");
-  return `nodes/${base}--annotations`;
-}
-async function syncAnnotationsNode(nestId, nodeId, userEmail) {
-  try {
-    let title = nodeId;
-    let type = null;
-    try {
-      const { storage } = await engineCache.get(nestId);
-      const node = await storage.readDocument(nodeId);
-      title = node.frontmatter?.title || nodeId;
-      type = node.frontmatter?.type || "document";
-    } catch {
-    }
-    if (type !== null && type !== "artifact") return;
-    const threads = await listThreads(nestId, nodeId);
-    const derivedTitle = `${title} \u2014 Annotations`;
-    const markdown = projectThreadsToMarkdown(title, threads);
-    const derivedId = derivedAnnotationsId(nodeId);
-    try {
-      await updateNode(nestId, derivedId, { content: markdown }, userEmail);
-    } catch (err) {
-      if (err instanceof NotFoundError) {
-        await createNode(
-          nestId,
-          {
-            id: derivedId,
-            title: derivedTitle,
-            content: markdown,
-            type: "document",
-            tags: ["annotations"]
-          },
-          userEmail
-        );
-      } else {
-        throw err;
-      }
-    }
-  } catch (err) {
-    console.warn(
-      `[annotations] failed to sync derived node for ${nestId}/${nodeId}:`,
-      err
-    );
-  }
-}
-
-// src/nodes/routes.ts
-var nodeRoutes = new Hono8();
-function nodeAsMarkdown(response, nodeId) {
-  return nodeToMarkdown({
-    id: nodeId,
-    title: response.title,
-    tags: response.tags,
-    status: response.status,
-    body: response.content
-  });
-}
-function rawNodeBody(c, response, storedRaw) {
-  const body = response.content ?? "";
-  const payload = c.req.query("frontmatter") === "1" ? frontmatterBlockOf(storedRaw) + body : body;
-  c.header("X-Content-Type-Options", "nosniff");
-  if ((response.type || "document") === "artifact") {
-    applyArtifactSandboxHeaders(c);
+function rawNodeBody(c, response, storedRaw) {
+  const body = response.content ?? "";
+  const payload = c.req.query("frontmatter") === "1" ? frontmatterBlockOf(storedRaw) + body : body;
+  c.header("X-Content-Type-Options", "nosniff");
+  if ((response.type || "document") === "artifact") {
+    applyArtifactSandboxHeaders(c);
   }
   return c.body(payload, 200, {
     "Content-Type": rawContentType(response.type)
@@ -4045,7 +4102,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) => {
@@ -4068,7 +4135,8 @@ nodeRoutes.post("/", async (c) => {
       scope: body.scope,
       status: body.status,
       schedule: body.schedule,
-      folder: body.folder
+      folder: body.folder,
+      prime: body.prime
     },
     authorEmail
   );
@@ -4085,7 +4153,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-G7IF7ZNP.js");
+  const { resolveStewardsWithFallback: resolveStewardsWithFallback2 } = await import("./stewardship-service-LTREGVSJ.js");
   const { stewards, fallbackToOwner, ownerEmail } = await resolveStewardsWithFallback2(
     nestId,
     nodeId
@@ -4103,42 +4171,10 @@ nodeRoutes.get("/:nodeId{.+}/stewards", async (c) => {
     ownerEmail
   });
 });
-nodeRoutes.get("/:nodeId{.+}/versions", async (c) => {
-  const nestId = c.req.param("nestId");
-  const nodeId = c.req.param("nodeId");
-  const { getVersions: getVersions2, getApprovedVersion: getApprovedVersion2 } = await import("./version-service-FGL47APL.js");
-  const allVersions = await getVersions2(nestId, nodeId);
-  const approved = await getApprovedVersion2(nestId, nodeId);
-  const db = getDb();
-  const resolutions = await db.all(
-    `SELECT version, status, resolved_by, resolved_at
-         FROM review_requests
-        WHERE nest_id = ? AND node_id = ?
-          AND status IN ('approved', 'rejected')
-          AND resolved_by IS NOT NULL
-        ORDER BY resolved_at DESC`,
-    [nestId, nodeId]
-  );
-  const byVersion = /* @__PURE__ */ new Map();
-  for (const r of resolutions) {
-    if (!byVersion.has(r.version)) {
-      byVersion.set(r.version, { status: r.status, resolvedBy: r.resolved_by });
-    }
-  }
-  const enriched = allVersions.map((v) => {
-    const r = byVersion.get(v.version);
-    return r ? { ...v, resolvedBy: r.resolvedBy, resolutionStatus: r.status } : v;
-  });
-  return c.json({
-    versions: enriched,
-    approvedVersion: approved,
-    currentVersion: allVersions[0]?.version || 0
-  });
-});
 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-6G7MVTY6.js");
+  const { getReviewHistory: getReviewHistory2 } = await import("./review-service-V2GR6VM3.js");
   const history = await getReviewHistory2(nestId, nodeId);
   return c.json({ reviews: history });
 });
@@ -4227,18 +4263,13 @@ nodeRoutes.get("/:nodeId{.+}", async (c) => {
   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}`);
-  }
+  let node = await getNodeForCaller(
+    nestId,
+    { id: nodeId },
+    userId,
+    userEmail,
+    { verifyChecksum: true }
+  );
   if (node.pendingChange) {
     try {
       await scanDocumentForDrift(nestId, nodeId, userEmail || "system:read");
@@ -4304,6 +4335,10 @@ nodeRoutes.get("/:nodeId{.+}", async (c) => {
     const pending = await getPendingReview(nestId, nodeId);
     response.pendingReviewBy = pending?.requestedBy ?? null;
   }
+  response.deletionRequest = await getLatestDeletionRequest(
+    nestId,
+    nodeId
+  );
   if (isRawFormat(c)) {
     return rawNodeBody(c, response, node.rawContent);
   }
@@ -4347,93 +4382,317 @@ nodeRoutes.patch("/:nodeId{.+}", async (c) => {
       title: body.title,
       status: body.status,
       changeNote: body.changeNote,
-      schedule: body.schedule
+      schedule: body.schedule,
+      prime: body.prime
     },
     authorEmail
   );
-  return c.json({ node: toNodeResponse(node), version: responseVersion });
-});
-nodeRoutes.delete("/:nodeId{.+}", async (c) => {
-  const nestId = c.req.param("nestId");
-  const nodeId = c.req.param("nodeId");
-  const { storage } = await engineCache.get(nestId);
-  if (await isStewardshipEnabled(nestId) && await getPendingReview(nestId, nodeId)) {
-    throw new LockedError(
-      "This document is awaiting steward review and is locked. Approve or reject the pending review before deleting."
-    );
-  }
-  try {
-    await storage.deleteDocument(nodeId);
-  } catch {
-    throw new NotFoundError(`Node not found: ${nodeId}`);
-  }
-  await removeNodeFromTagIndex(nestId, nodeId);
-  const derivedId = derivedAnnotationsId(nodeId);
-  try {
-    await storage.deleteDocument(derivedId);
-    await removeNodeFromTagIndex(nestId, derivedId);
-  } catch {
+  return c.json({ node: toNodeResponse(node), version: responseVersion });
+});
+nodeRoutes.delete("/:nodeId{.+}", async (c) => {
+  const nestId = c.req.param("nestId");
+  const nodeId = c.req.param("nodeId");
+  await deleteNode(nestId, nodeId, await getUserEmail(c));
+  return c.json({ deleted: true });
+});
+async function getUserEmail(c) {
+  const userId = c.get("userId");
+  const db = getDb();
+  const user = await db.get("SELECT email FROM users WHERE id = ?", [userId]);
+  return user?.email || "anonymous@localhost";
+}
+
+// src/annotations/routes.ts
+import { Hono as Hono9 } from "hono";
+
+// src/annotations/service.ts
+import { v4 as uuid5 } from "uuid";
+
+// src/annotations/projection.ts
+var MAX_CONTEXT_CHARS = 250;
+var MAX_QUOTE_CHARS = 1e3;
+function clampAnchor(raw) {
+  if (!raw) return null;
+  const quote = (raw.quote ?? "").trim().slice(0, MAX_QUOTE_CHARS);
+  if (!quote) return null;
+  const before = (raw.before ?? "").slice(-MAX_CONTEXT_CHARS);
+  const after = (raw.after ?? "").slice(0, MAX_CONTEXT_CHARS);
+  const line = typeof raw.line === "number" && Number.isFinite(raw.line) && raw.line > 0 ? Math.floor(raw.line) : void 0;
+  return { quote, before, after, ...line !== void 0 ? { line } : {} };
+}
+function oneLine(s) {
+  return s.replace(/\s+/g, " ").replace(/--+>/g, "-\u2192").trim();
+}
+function renderAnchor(anchor) {
+  if (!anchor) {
+    return "<!-- anchor: whole-artifact -->";
+  }
+  const linePart = anchor.line !== void 0 ? `line ${anchor.line} \xB7 ` : "";
+  const context = `\u2026${oneLine(anchor.before)}\u3008${oneLine(anchor.quote)}\u3009${oneLine(
+    anchor.after
+  )}\u2026`;
+  return `<!-- anchor: ${linePart}quote "${oneLine(anchor.quote)}" \xB7 context ${context} -->`;
+}
+function statusHeading(thread) {
+  if (thread.status === "resolved") {
+    const who = thread.resolvedBy ? `${thread.resolvedBy}, ` : "";
+    const when = thread.resolvedAt ? `${thread.resolvedAt}` : "";
+    const meta = who || when ? ` (${who}${when})` : "";
+    return `\u2705 RESOLVED${meta}`;
+  }
+  return "\u{1F7E0} OPEN";
+}
+function snapshotLabel(v) {
+  return v == null ? "Unpinned" : `Snapshot v${v}`;
+}
+function orderThreads(threads) {
+  return [...threads].sort((a, b) => {
+    if (a.status !== b.status) return a.status === "open" ? -1 : 1;
+    return a.createdAt.localeCompare(b.createdAt);
+  });
+}
+function projectThreadsToMarkdown(artifactTitle, threads) {
+  const lines = [];
+  lines.push(`# ${artifactTitle} \u2014 Annotations`);
+  lines.push("");
+  lines.push(
+    "> Auto-generated from review comments, grouped by the artifact snapshot each was anchored to. **Open** threads are unresolved feedback for the next iteration; **resolved** threads were already addressed (don't re-break them)."
+  );
+  lines.push("");
+  if (threads.length === 0) {
+    lines.push("_No annotations yet._");
+    lines.push("");
+    return lines.join("\n");
+  }
+  const buckets2 = /* @__PURE__ */ new Map();
+  for (const t of threads) {
+    const key = t.snapshotVersion ?? null;
+    (buckets2.get(key) ?? buckets2.set(key, []).get(key)).push(t);
+  }
+  const keys = [...buckets2.keys()].sort((a, b) => {
+    if (a == null) return 1;
+    if (b == null) return -1;
+    return b - a;
+  });
+  for (const key of keys) {
+    lines.push(`## ${snapshotLabel(key)}`);
+    lines.push("");
+    for (const thread of orderThreads(buckets2.get(key))) {
+      lines.push(`### Thread \xB7 ${statusHeading(thread)}`);
+      lines.push(renderAnchor(thread.anchor));
+      for (const comment of thread.comments) {
+        lines.push(
+          `- **${comment.author}** \xB7 ${comment.createdAt} \u2014 ${comment.body}`
+        );
+      }
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/annotations/service.ts
+async function loadComments(threadId) {
+  const db = getDb();
+  const rows = await db.all(
+    "SELECT id, author, body, created_at FROM annotation_comments WHERE thread_id = ? ORDER BY created_at ASC, id ASC",
+    [threadId]
+  );
+  return rows.map((r) => ({
+    id: r.id,
+    author: r.author,
+    body: r.body,
+    createdAt: r.created_at
+  }));
+}
+async function rowToThread(row) {
+  let anchor = null;
+  if (row.anchor_json) {
+    try {
+      anchor = JSON.parse(row.anchor_json);
+    } catch {
+      anchor = null;
+    }
+  }
+  return {
+    id: row.id,
+    nestId: row.nest_id,
+    nodeId: row.node_id,
+    snapshotVersion: row.snapshot_version,
+    anchor,
+    status: row.status,
+    createdBy: row.created_by,
+    createdAt: row.created_at,
+    resolvedBy: row.resolved_by,
+    resolvedAt: row.resolved_at,
+    comments: await loadComments(row.id)
+  };
+}
+async function getThreadRow(threadId) {
+  return await getDb().get("SELECT * FROM annotation_threads WHERE id = ?", [threadId]);
+}
+async function countThreadsByNode(nestId) {
+  const rows = await getDb().all(
+    `SELECT node_id, CAST(COUNT(*) AS INTEGER) AS count, MAX(created_at) AS last_at
+         FROM annotation_threads
+        WHERE nest_id = ?
+        GROUP BY node_id`,
+    [nestId]
+  );
+  const out = {};
+  for (const r of rows) out[r.node_id] = { count: r.count, lastAt: r.last_at };
+  return out;
+}
+async function listThreads(nestId, nodeId) {
+  const rows = await getDb().all(
+    "SELECT * FROM annotation_threads WHERE nest_id = ? AND node_id = ? ORDER BY created_at ASC, id ASC",
+    [nestId, nodeId]
+  );
+  return Promise.all(rows.map(rowToThread));
+}
+async function createThread(nestId, nodeId, input, authorEmail) {
+  const body = (input.body ?? "").trim();
+  if (!body) {
+    throw new Error("comment body is required");
   }
   const db = getDb();
+  const id = uuid5();
+  const anchor = clampAnchor(input.anchor);
+  const snapshot = input.snapshotVersion ?? await getApprovedVersion(nestId, nodeId) ?? null;
   await db.transaction(async (tx) => {
     await tx.run(
-      "DELETE FROM node_versions WHERE nest_id = ? AND node_id = ?",
-      [nestId, nodeId]
-    );
-    await tx.run(
-      "DELETE FROM review_requests WHERE nest_id = ? AND node_id = ?",
-      [nestId, nodeId]
-    );
-    await tx.run(
-      "DELETE FROM approved_versions WHERE nest_id = ? AND node_id = ?",
-      [nestId, nodeId]
-    );
-    await tx.run(
-      `DELETE FROM stewards
-       WHERE nest_id = ? AND scope = 'document' AND node_pattern = ?`,
-      [nestId, nodeId]
-    );
-    await tx.run(
-      "DELETE FROM annotation_threads WHERE nest_id = ? AND node_id = ?",
-      [nestId, nodeId]
-    );
-    await tx.run(
-      "DELETE FROM node_versions WHERE nest_id = ? AND node_id = ?",
-      [nestId, derivedId]
+      `INSERT INTO annotation_threads
+         (id, nest_id, node_id, snapshot_version, anchor_json, status, created_by)
+       VALUES (?, ?, ?, ?, ?, 'open', ?)`,
+      [
+        id,
+        nestId,
+        nodeId,
+        snapshot,
+        anchor ? JSON.stringify(anchor) : null,
+        authorEmail
+      ]
     );
     await tx.run(
-      "DELETE FROM review_requests WHERE nest_id = ? AND node_id = ?",
-      [nestId, derivedId]
+      "INSERT INTO annotation_comments (id, thread_id, author, body) VALUES (?, ?, ?, ?)",
+      [uuid5(), id, authorEmail, body]
     );
-    await tx.run(
-      "DELETE FROM approved_versions WHERE nest_id = ? AND node_id = ?",
-      [nestId, derivedId]
+  });
+  return rowToThread(await getThreadRow(id));
+}
+async function getScopedThreadRow(threadId, nestId, nodeId) {
+  const row = await getThreadRow(threadId);
+  if (!row || row.nest_id !== nestId || row.node_id !== nodeId) {
+    throw new NotFoundError(`Thread not found: ${threadId}`);
+  }
+  return row;
+}
+async function addComment(nestId, nodeId, threadId, authorEmail, body) {
+  const trimmed = (body ?? "").trim();
+  if (!trimmed) {
+    throw new Error("comment body is required");
+  }
+  await getScopedThreadRow(threadId, nestId, nodeId);
+  await getDb().run(
+    "INSERT INTO annotation_comments (id, thread_id, author, body) VALUES (?, ?, ?, ?)",
+    [uuid5(), threadId, authorEmail, trimmed]
+  );
+  return rowToThread(await getThreadRow(threadId));
+}
+async function setThreadStatus(nestId, nodeId, threadId, status, byEmail) {
+  await getScopedThreadRow(threadId, nestId, nodeId);
+  const db = getDb();
+  if (status === "resolved") {
+    await db.run(
+      `UPDATE annotation_threads SET status = 'resolved', resolved_by = ?, resolved_at = ${nowExpr(db)} WHERE id = ?`,
+      [byEmail, threadId]
     );
-    await tx.run(
-      "DELETE FROM annotation_threads WHERE nest_id = ? AND node_id = ?",
-      [nestId, derivedId]
+  } else {
+    await db.run(
+      "UPDATE annotation_threads SET status = 'open', resolved_by = NULL, resolved_at = NULL WHERE id = ?",
+      [threadId]
     );
-    await tx.run(
-      `INSERT INTO node_deletions (nest_id, node_id, deleted_by, deleted_at)
-       VALUES (?, ?, ?, ?)
-       ON CONFLICT(nest_id, node_id) DO UPDATE
-         SET deleted_by = excluded.deleted_by, deleted_at = excluded.deleted_at`,
-      [nestId, nodeId, await getUserEmail(c), (/* @__PURE__ */ new Date()).toISOString()]
+  }
+  return rowToThread(await getThreadRow(threadId));
+}
+async function readArtifact(nestId, nodeId, version) {
+  const { storage, versions: versionManager } = await engineCache.get(nestId);
+  const target = version ?? await getApprovedVersion(nestId, nodeId) ?? null;
+  let title = nodeId;
+  let type = null;
+  let liveHtml = "";
+  let liveExists = true;
+  try {
+    const node = await storage.readDocument(nodeId);
+    title = node.frontmatter?.title || nodeId;
+    type = node.frontmatter?.type || null;
+    liveHtml = node.body || "";
+  } catch {
+    liveExists = false;
+  }
+  if (target != null) {
+    try {
+      const raw = await versionManager.reconstructVersion(nodeId, target);
+      return { title, html: bodyOnly(nodeId, raw), version: target, type };
+    } catch (err) {
+      console.warn(
+        `[annotations] reconstruct v${target} failed for ${nestId}/${nodeId}; falling back to live body:`,
+        err
+      );
+    }
+  }
+  if (!liveExists) {
+    throw new NotFoundError(`Artifact not found: ${nodeId}`);
+  }
+  return { title, html: liveHtml, version: target, type };
+}
+function derivedAnnotationsId(sourceNodeId) {
+  const base = sourceNodeId.replace(/^nodes\//, "");
+  return `nodes/${base}--annotations`;
+}
+async function syncAnnotationsNode(nestId, nodeId, userEmail) {
+  try {
+    let title = nodeId;
+    let type = null;
+    try {
+      const { storage } = await engineCache.get(nestId);
+      const node = await storage.readDocument(nodeId);
+      title = node.frontmatter?.title || nodeId;
+      type = node.frontmatter?.type || "document";
+    } catch {
+    }
+    if (type !== null && type !== "artifact") return;
+    const threads = await listThreads(nestId, nodeId);
+    const derivedTitle = `${title.slice(0, 100)} \u2014 Annotations`;
+    const markdown = projectThreadsToMarkdown(title, threads);
+    const derivedId = derivedAnnotationsId(nodeId);
+    try {
+      await updateNode(nestId, derivedId, { content: markdown }, userEmail);
+    } catch (err) {
+      if (err instanceof NotFoundError) {
+        await createNode(
+          nestId,
+          {
+            id: derivedId,
+            title: derivedTitle,
+            content: markdown,
+            type: "document",
+            tags: ["annotations"]
+          },
+          userEmail
+        );
+      } else {
+        throw err;
+      }
+    }
+  } catch (err) {
+    console.warn(
+      `[annotations] failed to sync derived node for ${nestId}/${nodeId}:`,
+      err
     );
-  });
-  await trackEvent("node.delete", { nestId, nodeId });
-  return c.json({ deleted: true });
-});
-async function getUserEmail(c) {
-  const userId = c.get("userId");
-  const db = getDb();
-  const user = await db.get("SELECT email FROM users WHERE id = ?", [userId]);
-  return user?.email || "anonymous@localhost";
+  }
 }
 
-// src/annotations/routes.ts
-import { Hono as Hono9 } from "hono";
-
 // src/annotations/types.ts
 var ARTIFACT_NODE_TYPE = "artifact";
 
@@ -5527,29 +5786,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(documents, 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(toSearchHit)
   });
 });
 queryRoutes.get("/overview", async (c) => {
@@ -5708,6 +5952,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(
     {
@@ -5724,6 +5969,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;
@@ -5794,38 +6063,14 @@ async function listTraceEvents(filters = {}) {
       [...args, limit, offset]
     );
     return { events, total };
-  } catch {
-    return { events: [], total: 0 };
-  }
-}
-
-// 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)");
-    }
+  } catch {
+    return { events: [], total: 0 };
   }
-  return id;
 }
 
+// src/mcp/workflow-tools.ts
+import { v4 as uuid8 } from "uuid";
+
 // src/workflow/run-service.ts
 import { v4 as uuid6 } from "uuid";
 var RUNNABLE_TYPES = ["agent", "skill"];
@@ -6221,6 +6466,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");
@@ -6291,6 +6548,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);
     }
@@ -6318,6 +6576,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(?))",
@@ -6328,9 +6588,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;
@@ -6344,11 +6602,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) });
 });
@@ -6683,6 +6949,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);
     }
@@ -6783,6 +7050,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",
@@ -6851,12 +7142,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" }
       }
     }
@@ -6909,7 +7211,7 @@ var TOOL_DEFINITIONS = [
   },
   {
     name: "context_create",
-    description: "Create a new knowledge node in the vault.",
+    description: "Create a new knowledge node in the vault. The title must not already be in use \u2014 these tools resolve documents by title, so a duplicate is refused rather than filed as an unreachable twin. To change an existing document use context_update; to refile it use context_move.",
     inputSchema: {
       type: "object",
       properties: {
@@ -6930,7 +7232,7 @@ var TOOL_DEFINITIONS = [
         scope: { type: "string", description: "Visibility scope" },
         folder: {
           type: "string",
-          description: 'Folder path under nodes/ (e.g. "gtm/deals"); segments are slugified'
+          description: 'Folder path under nodes/ (e.g. "gtm/deals"); segments are slugified. A leading "nodes/" is accepted and not doubled, so "nodes/gtm/deals" and "gtm/deals" mean the same folder.'
         }
       },
       required: ["title", "content"]
@@ -6938,13 +7240,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",
@@ -6956,9 +7265,62 @@ var TOOL_DEFINITIONS = [
           items: { type: "string" },
           description: "Tags to add"
         },
-        scope: { type: "string", description: "New scope" }
+        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.
+    }
+  },
+  {
+    name: "context_delete",
+    // Mirrors the engine's canonical `context_delete` operation (core
+    // namespace, alias delete_document): same name, same {id, title} input,
+    // same "deleted" semantics. The engine's `uri` field is omitted — this
+    // repo has no contextnest:// resolver on any surface, so accepting one
+    // would promise a resolution it can't do.
+    description: "Delete a node from the vault by title or id. Removes everything keyed to it: version history, review state, annotations, comments, watchers, schedules, trigger hooks, workflow edges, document grants, and any steward assignments scoped to it. Irreversible \u2014 the node must be recreated to come back, and it comes back clean: no history, no stewards, no shares. A node under open review is frozen unless you can approve it (owner, admin, or its reviewer).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        title: { type: "string", description: "Title of node to delete" },
+        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.'
+        }
+      }
+    }
+  },
+  {
+    name: "context_move",
+    // NOT in the engine's operation catalog — `move` is a community-edition
+    // concern (the id rewrite spans governance tables the engine doesn't own).
+    // This mirrors the existing REST POST /nodes/:id/move rather than adding a
+    // new concept, so the surfaces agree. If move is ever promoted to a core
+    // operation upstream, adopt that descriptor and drop this schema.
+    description: "Move a node to a different folder. The id changes; version history, review state, annotations, comments, watchers, schedules, links, and document grants all follow. The title and its [[wiki-link]] stay valid. A node under open review is frozen unless you can approve it (owner, admin, or its reviewer).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        title: { type: "string", description: "Title of node to move" },
+        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.'
+        },
+        folder: {
+          type: "string",
+          description: 'Destination folder under nodes/ (e.g. "gtm/deals"); segments are slugified. Use "" to move to the nest root.'
+        }
       },
-      required: ["title"]
+      required: ["folder"]
     }
   },
   // ─── Governance Tools ───────────────────────────────────────────────
@@ -6975,6 +7337,73 @@ var TOOL_DEFINITIONS = [
       }
     }
   },
+  {
+    // Deletion requests, mirroring the REST + UI flow: anyone who can READ a
+    // thing may ask for it to be deleted; only an owner/admin resolves it.
+    // Not in the engine catalog (1.2.1) — deletion requests live in this
+    // 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 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: {
+        title: { type: "string", description: "Title of the document to flag" },
+        id: {
+          type: "string",
+          description: 'Document id / path (e.g. "nodes/gtm/deals/win-loss-log"). Use instead of title when two documents share a title.'
+        },
+        folder: {
+          type: "string",
+          description: 'Flag a whole folder instead of a document \u2014 the path, e.g. "gtm/deals". Every document under it goes if the request is honoured.'
+        },
+        nest: {
+          type: "boolean",
+          description: "Flag the ENTIRE nest for deletion. Only an owner/admin can honour it."
+        },
+        reason: {
+          type: "string",
+          description: "Why it should be deleted. Required \u2014 this is what the admin judges."
+        }
+      },
+      required: ["reason"]
+    }
+  },
+  {
+    name: "context_deletion_queue",
+    description: "Show deletion requests waiting on a nest owner/admin: what was flagged, who asked, and why. Use the request id with context_resolve_deletion to action one.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        status: {
+          type: "string",
+          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 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: {
+        request_id: {
+          type: "string",
+          description: "Request id from context_deletion_queue"
+        },
+        action: {
+          type: "string",
+          description: '"delete" to honour it, "decline" to reject it and keep the target'
+        },
+        note: {
+          type: "string",
+          description: 'Why you rejected it. Required when action is "decline".'
+        }
+      },
+      required: ["request_id", "action"]
+    }
+  },
   {
     name: "context_review_queue",
     description: "Show documents pending review. These need a steward to approve or reject them before they become available to AI.",
@@ -6988,6 +7417,14 @@ var TOOL_DEFINITIONS = [
       }
     }
   },
+  {
+    name: "context_my_drafts",
+    description: "List YOUR unsubmitted drafts in this nest \u2014 documents you wrote that were never submitted for review (plus any that came back rejected). These are invisible to the review queue and unreadable by AI queries until submitted and approved. Use context_submit_review to hand one to a steward.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
   {
     name: "context_submit_review",
     description: "Submit a node for steward review. The node will be marked as pending review and stewards will be notified.",
@@ -7031,9 +7468,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.
     }
   },
   {
@@ -7140,40 +7581,69 @@ async function handleToolCall(toolName, args, ctx) {
     });
   }
 }
+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(assertSafeNodeId(args.id));
+    } catch {
+      return `Node not found: ${args.id}`;
+    }
+  }
+  const docs = await storage.discoverDocuments();
+  const matches = docs.filter(
+    (n) => n.frontmatter.title.toLowerCase() === args.title.toLowerCase()
+  );
+  if (matches.length > 1) {
+    return `${matches.length} nodes share the title "${args.title}". Re-run with one of these ids instead: ${matches.map((n) => n.id).join(", ")}`;
+  }
+  return matches[0] ?? `Node not found: ${args.title}`;
+}
 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
 
@@ -7195,14 +7665,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(
@@ -7219,61 +7701,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, {
@@ -7371,43 +7911,125 @@ ${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 { node } = await createNode(
-        nestId,
-        {
-          title: args.title,
-          content: args.content,
-          type: args.type,
-          tags: args.tags,
-          scope: args.scope,
-          folder: args.folder
-        },
-        userEmail
-      );
-      return `Created node: **${args.title}** (${node.id}) \u2014 status: ${node.frontmatter.status}`;
+      const wanted = String(args.title ?? "").toLowerCase();
+      return withNodeWriteLock(nodeWriteKey(nestId, "*create*"), async () => {
+        const existingDocs = await storage.discoverDocuments();
+        const twin = existingDocs.find(
+          (n) => String(n.frontmatter.title ?? "").toLowerCase() === wanted
+        );
+        if (twin) {
+          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, version } = await createNode(
+          nestId,
+          {
+            title: args.title,
+            content: args.content,
+            type: args.type,
+            tags: args.tags,
+            scope: args.scope,
+            folder: args.folder
+          },
+          userEmail
+        );
+        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 toolError(node, "DOCUMENT_NOT_FOUND");
+      const deleteCheck = await canUserEdit(nestId, node.id, userEmail);
+      if (!deleteCheck.allowed) {
+        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.`,
+          "UNAUTHORIZED_ACTION"
+        );
+      }
+      await deleteNode(nestId, node.id, userEmail);
+      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") {
+        return 'folder is required \u2014 a path like "gtm/deals", or "" for the nest root.';
+      }
+      const node = await resolveTargetNode(storage, args);
+      if (typeof node === "string") return node;
+      const moveCheck = await canUserEdit(nestId, node.id, userEmail);
+      if (!moveCheck.allowed) {
+        return `You don't have permission to move "${node.frontmatter.title}": ${moveCheck.reason}`;
+      }
+      const { node: moved, previousId } = await moveNode(
+        nestId,
+        node.id,
+        args.folder,
+        userEmail
+      );
+      if (previousId === moved.id) {
+        return `**${moved.frontmatter.title}** is already at \`${moved.id}\` \u2014 nothing to move.`;
+      }
+      return `Moved **${moved.frontmatter.title}**: \`${previousId}\` \u2192 \`${moved.id}\``;
     }
     // ─── Governance Tool Handlers ──────────────────────────────────────
     case "context_stewards": {
@@ -7448,6 +8070,126 @@ ${stewards.map((s) => `- **${s.userEmail}** (${s.role})${s.role === "reviewer" ?
 
 ${sections}`;
     }
+    case "context_request_deletion": {
+      const reason = typeof args.reason === "string" ? args.reason.trim() : "";
+      if (!reason) {
+        return "reason is required \u2014 say why it should be deleted; that is what the admin judges.";
+      }
+      if (args.nest === true) {
+        const request2 = await requestDeletion({
+          nestId,
+          nodeId: nestId,
+          targetType: "nest",
+          requestedBy: userEmail,
+          reason,
+          baseUrl: ctx.baseUrl
+        });
+        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()) {
+        const folder = args.folder.trim().replace(/^\/+|\/+$/g, "").replace(/^nodes\//, "");
+        const docs = await storage.discoverDocuments();
+        const inside = docs.filter((d) => isIdUnderFolder(d.id, folder));
+        if (inside.length === 0) {
+          return `No folder "${folder}" \u2014 nothing is filed under it. Use context_list to see what exists.`;
+        }
+        const request2 = await requestDeletion({
+          nestId,
+          nodeId: folder,
+          targetType: "folder",
+          requestedBy: userEmail,
+          reason,
+          baseUrl: ctx.baseUrl
+        });
+        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);
+      if (typeof node === "string") return node;
+      if (!await canReadNode(nestId, node.id, userId, userEmail)) {
+        return `Node not found: ${node.id}`;
+      }
+      const request = await requestDeletion({
+        nestId,
+        nodeId: node.id,
+        targetType: "document",
+        requestedBy: userEmail,
+        reason,
+        baseUrl: ctx.baseUrl
+      });
+      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 rejected deletion requests.";
+      }
+      const list = requests.map((r, i) => {
+        const kind = r.targetType === "document" ? "" : `${r.targetType}: `;
+        const verdict = r.status === "declined" ? `
+   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}`;
+      }).join("\n\n");
+      return `# Deletion requests (${status})
+**${requests.length} item(s)**
+
+${list}`;
+    }
+    case "context_resolve_deletion": {
+      const requestId = typeof args.request_id === "string" ? args.request_id : "";
+      const action = args.action === "delete" ? "delete" : args.action === "decline" ? "decline" : null;
+      if (!requestId || !action) {
+        return 'request_id and action are required \u2014 action is "delete" or "decline". Use context_deletion_queue to list request ids.';
+      }
+      const request = await getDeletionRequest(requestId);
+      if (!request || request.nestId !== nestId || request.status !== "pending") {
+        return `No pending deletion request with id ${requestId}.`;
+      }
+      const roles = await resolveUserRoles(nestId, userEmail);
+      if (!roles.includes("owner") && !roles.includes("admin")) {
+        return `You don't have permission to resolve deletion requests in this nest \u2014 only a nest owner or admin can. You can add to the discussion, but the verdict is theirs.`;
+      }
+      const label = await deletionTargetTitle(request);
+      if (action === "decline") {
+        const note = typeof args.note === "string" ? args.note.trim() : "";
+        if (!note) {
+          return "note is required when rejecting \u2014 the requester is told why it stays.";
+        }
+        await declineDeletion({
+          nestId,
+          id: requestId,
+          declinedBy: userEmail,
+          note,
+          baseUrl: ctx.baseUrl
+        });
+        return `Rejected the deletion request for **${label}**. It stays, and ${request.requestedBy} has been told why.`;
+      }
+      if (request.targetType === "nest") {
+        await deleteNest(nestId);
+      } else if (request.targetType === "folder") {
+        await deleteFolder(nestId, request.nodeId, userEmail);
+        await dropDeletionRequest(request.id);
+      } else {
+        await deleteNode(nestId, request.nodeId, userEmail);
+      }
+      await notifyDeletionResolved({
+        nestId,
+        nodeId: request.nodeId,
+        docTitle: label,
+        outcome: "deleted",
+        requestedBy: request.requestedBy,
+        resolvedBy: userEmail,
+        requestId: request.id,
+        targetType: request.targetType,
+        baseUrl: ctx.baseUrl
+      });
+      return `Deleted **${label}** \u2014 ${request.requestedBy}'s request was honoured. Irreversible.`;
+    }
     case "context_review_queue": {
       const status = args.status || "pending";
       const result = await getReviewQueue({
@@ -7466,19 +8208,47 @@ ${sections}`;
 **${result.total} item(s)**
 
 ${list}`;
+    }
+    case "context_my_drafts": {
+      const { drafts, total } = await listMyDrafts({
+        authorEmail: userEmail,
+        nestIds: [ctx.nestId],
+        limit: 100
+      });
+      if (total === 0) {
+        return "No unsubmitted drafts \u2014 everything you've written here is in review or approved.";
+      }
+      const list = drafts.map(
+        (d, i) => `${i + 1}. **${d.title}** v${d.version} \u2014 ${d.status}
+   Path: ${d.nodeId}
+   Last edited: ${d.updatedAt}`
+      ).join("\n\n");
+      const more = total > drafts.length ? `
+
+_Showing the ${drafts.length} most recent of ${total}._` : "";
+      return `# My Drafts
+**${total} unsubmitted document(s)**
+
+${list}${more}
+
+Submit one with \`context_submit_review\`.`;
     }
     case "context_submit_review": {
       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}`;
+      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,
@@ -7497,9 +8267,33 @@ ${list}`;
 
 **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": {
@@ -7543,23 +8337,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;
@@ -7617,8 +8434,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-5ZFISCBH.js");
-        const db = (await import("./client-3MGIP57D.js")).getDb();
+        const { createGrant: createGrant2 } = await import("./grants-service-I535QVTW.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.";
@@ -7711,7 +8528,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,
@@ -7720,7 +8537,7 @@ function createMcpServerForNest(nestId, userId, userEmail, baseUrl) {
         userEmail,
         baseUrl
       });
-      return { content: [{ type: "text", text }] };
+      return toCallToolResult(out);
     });
   }
   return server;
@@ -8797,6 +9614,7 @@ import { Hono as Hono19 } from "hono";
 import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { WebStandardStreamableHTTPServerTransport as WebStandardStreamableHTTPServerTransport2 } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
 import { z as z2 } from "zod";
+var SERVER_WRITE_TOOLS = /* @__PURE__ */ new Set(["nest_create", "context_create"]);
 async function getUserEmail3(userId) {
   const db = getDb();
   const user = await db.get("SELECT email FROM users WHERE id = ?", [
@@ -8978,6 +9796,38 @@ var SERVER_TOOL_DEFINITIONS = [
       },
       required: ["nest", "selector"]
     }
+  },
+  {
+    name: "nest_create",
+    description: "Create a new nest owned by the caller. Returns the new nest's id \u2014 target it with the other tools afterwards.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Nest name" },
+        description: { type: "string", description: "Optional description" }
+      },
+      required: ["name"]
+    }
+  },
+  {
+    name: "context_create",
+    description: "Create a new knowledge node (document) in a nest. Needs write permission on that nest. A `folder` path creates the folder implicitly \u2014 folders exist through the nodes placed in them.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        ...NEST_ARG,
+        title: { type: "string", description: "Descriptive title" },
+        content: { type: "string", description: "Markdown content body" },
+        type: { type: "string", description: "Node type (default: document)" },
+        tags: { type: "array", items: { type: "string" }, description: "Tags" },
+        scope: { type: "string", description: "Visibility scope" },
+        folder: {
+          type: "string",
+          description: 'Folder path under nodes/ (e.g. "gtm/deals"); segments are slugified'
+        }
+      },
+      required: ["nest", "title", "content"]
+    }
   }
 ];
 async function handleServerToolCall(toolName, args, userId, userEmail, nestScope, baseUrl) {
@@ -8986,6 +9836,31 @@ async function handleServerToolCall(toolName, args, userId, userEmail, nestScope
     if (!nests.length) return "No nests accessible with these credentials.";
     return renderNestIndexMarkdown(nests, baseUrl);
   }
+  if (SERVER_WRITE_TOOLS.has(toolName)) {
+    if (isSuspended()) {
+      const reason = getSuspensionReason();
+      return `This server is suspended by PromptOwl; writes are blocked${reason ? ` \u2014 ${reason}` : ""}. Contact support@promptowl.ai.`;
+    }
+    if (!getCurrentLicense()?.valid) {
+      return "This server has no valid PromptOwl license installed, so writes are disabled. Ask the server admin to install one (POST /license/install).";
+    }
+  }
+  if (toolName === "nest_create") {
+    if (nestScope) {
+      return "This credential is scoped to a single nest and cannot create new ones.";
+    }
+    try {
+      const nest2 = await createNest(
+        userId,
+        String(args.name ?? ""),
+        args.description ? String(args.description) : void 0
+      );
+      return `Created nest "${nest2.name}" (id: ${nest2.id}). Add documents with context_create, retrieve with the other tools.`;
+    } catch (err) {
+      if (err instanceof ValidationError) return err.message;
+      throw err;
+    }
+  }
   const inaccessible = `Nest not found or not accessible: "${args.nest}". Use nest_index to see what these credentials can read.`;
   const nest = await resolveNestRef(String(args.nest ?? ""), userId);
   if (!nest) return inaccessible;
@@ -9021,7 +9896,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,
@@ -9029,7 +9904,7 @@ function createServerMcp(userId, userEmail, nestScope, baseUrl) {
         nestScope,
         baseUrl
       );
-      return { content: [{ type: "text", text }] };
+      return toCallToolResult(out);
     });
   }
   return server;
@@ -9144,7 +10019,9 @@ Streamable HTTP, stateless. Two endpoints:
   Tools: \`nest_index\` (call first), then \`context_query\`, \`context_search\`,
   \`context_get\`, \`context_list\`, \`context_overview\`, \`context_resolve\` \u2014
   each takes a \`nest\` argument (id or exact name) plus the same
-  selector/hops/max_tokens parameters as the REST API. Read-only.
+  selector/hops/max_tokens parameters as the REST API. Two bootstrap writes:
+  \`nest_create\` (new nest owned by the caller) and \`context_create\`
+  (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).
 
@@ -9737,6 +10614,123 @@ governanceRoutes.get("/review-queue", async (c) => {
   }
   return c.json({ ...result, requests });
 });
+function denyUnlessNestManager(c, what) {
+  const permission = c.get("nestPermission");
+  if (permission === "owner" || permission === "admin") return null;
+  return c.json(
+    {
+      error: `Only the nest owner or an admin can delete ${what}. Request its deletion instead, or ask an admin to action it.`
+    },
+    403
+  );
+}
+governanceRoutes.post("/delete-folder", async (c) => {
+  const nestId = c.req.param("nestId");
+  const denied = denyUnlessNestManager(c, "a folder");
+  if (denied) return denied;
+  const body = await c.req.json().catch(() => ({}));
+  if (!body.folder?.trim()) {
+    throw new ValidationError("folder is required");
+  }
+  const deleted = await deleteFolder(
+    nestId,
+    body.folder.trim(),
+    await getUserEmail4(c)
+  );
+  return c.json({ deleted: deleted.length, nodeIds: deleted });
+});
+governanceRoutes.post("/request-deletion", async (c) => {
+  const nestId = c.req.param("nestId");
+  const body = await c.req.json().catch(() => ({}));
+  const reason = body.reason?.trim();
+  if (!reason) {
+    throw new ValidationError("A reason for the deletion request is required");
+  }
+  if (body.targetType !== "folder" && body.targetType !== "nest") {
+    throw new ValidationError(
+      'targetType must be "folder" or "nest" \u2014 flag a single document via POST /nests/:nestId/nodes/:nodeId/request-deletion'
+    );
+  }
+  const target = body.targetType === "nest" ? nestId : (body.target || "").trim().replace(/^\/+|\/+$/g, "").replace(/^nodes\//, "");
+  if (body.targetType === "folder" && !target) {
+    throw new ValidationError("target (the folder path) is required");
+  }
+  if (body.targetType === "folder") {
+    const { storage } = await engineCache.get(nestId);
+    const docs = await storage.discoverDocuments();
+    if (!docs.some((d) => isIdUnderFolder(d.id, target))) {
+      return c.json({ error: `Folder not found: ${target}` }, 404);
+    }
+  }
+  const request = await requestDeletion({
+    nestId,
+    nodeId: target,
+    targetType: body.targetType,
+    requestedBy: await getUserEmail4(c),
+    reason,
+    baseUrl: requestBaseUrl(c.req.url)
+  });
+  return c.json({ request }, 201);
+});
+governanceRoutes.get("/deletion-requests", async (c) => {
+  const nestId = c.req.param("nestId");
+  const raw = c.req.query("status");
+  const status = raw === "declined" || raw === "all" ? raw : "pending";
+  const requests = await listDeletionRequests({ nestId, status });
+  return c.json({ requests, total: requests.length });
+});
+governanceRoutes.post("/deletion-requests/:id/delete", async (c) => {
+  const nestId = c.req.param("nestId");
+  const request = await getDeletionRequest(c.req.param("id"));
+  if (!request || request.nestId !== nestId || request.status !== "pending") {
+    return c.json({ error: "Deletion request not found" }, 404);
+  }
+  const actor = await getUserEmail4(c);
+  const docTitle = await deletionTargetTitle(request);
+  if (request.targetType === "nest" || request.targetType === "folder") {
+    const denied = denyUnlessNestManager(
+      c,
+      request.targetType === "nest" ? "a nest" : "a folder"
+    );
+    if (denied) return denied;
+  }
+  if (request.targetType === "nest") {
+    await deleteNest(nestId);
+  } else if (request.targetType === "folder") {
+    await deleteFolder(nestId, request.nodeId, actor);
+    await dropDeletionRequest(request.id);
+  } else {
+    await deleteNode(nestId, request.nodeId, actor);
+  }
+  await notifyDeletionResolved({
+    nestId,
+    nodeId: request.nodeId,
+    docTitle,
+    outcome: "deleted",
+    requestedBy: request.requestedBy,
+    resolvedBy: actor,
+    requestId: request.id,
+    targetType: request.targetType,
+    baseUrl: requestBaseUrl(c.req.url)
+  });
+  return c.json({ deleted: true, nodeId: request.nodeId });
+});
+governanceRoutes.post("/deletion-requests/:id/decline", async (c) => {
+  const nestId = c.req.param("nestId");
+  const body = await c.req.json().catch(() => ({}));
+  if (!body.note?.trim()) {
+    throw new ValidationError("A note is required when declining");
+  }
+  const request = await declineDeletion({
+    nestId,
+    id: c.req.param("id"),
+    declinedBy: await getUserEmail4(c),
+    note: body.note.trim(),
+    baseUrl: requestBaseUrl(c.req.url)
+  });
+  if (!request) return c.json({ error: "Deletion request not found" }, 404);
+  return c.json({ request });
+});
 governanceRoutes.get("/feed", async (c) => {
   const nestId = c.req.param("nestId");
   const filterRaw = c.req.query("filter");
@@ -9798,25 +10792,78 @@ governanceNodeRoutes.get("/:nodeId{.+}/stewards", async (c) => {
 governanceNodeRoutes.get("/:nodeId{.+}/versions", async (c) => {
   const nestId = c.req.param("nestId");
   const nodeId = c.req.param("nodeId");
+  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
+    );
+  }
   const allVersions = await getVersions(nestId, nodeId);
   const approved = await getApprovedVersion(nestId, nodeId);
   const { versions: versionManager } = await engineCache.get(nestId);
-  const withContent = await Promise.all(
+  const resolutions = await getDb().all(
+    `SELECT version, status, resolved_by
+       FROM review_requests
+      WHERE nest_id = ? AND node_id = ?
+        AND status IN ('approved', 'rejected')
+        AND resolved_by IS NOT NULL
+      ORDER BY resolved_at DESC`,
+    [nestId, nodeId]
+  );
+  const byVersion = /* @__PURE__ */ new Map();
+  for (const r of resolutions) {
+    if (!byVersion.has(r.version)) {
+      byVersion.set(r.version, { status: r.status, resolvedBy: r.resolved_by });
+    }
+  }
+  const enriched = await Promise.all(
     allVersions.map(async (v) => {
+      const r = byVersion.get(v.version);
+      const resolution = r ? { resolvedBy: r.resolvedBy, resolutionStatus: r.status } : {};
       try {
-        const raw = await versionManager.reconstructVersion(nodeId, v.version);
-        return { ...v, content: bodyOnly(nodeId, raw) };
+        const diff = await versionManager.getDiff(nodeId, v.version);
+        return { ...v, ...resolution, diff: diff ?? void 0 };
       } catch {
-        return v;
+        return { ...v, ...resolution };
       }
     })
   );
   return c.json({
-    versions: withContent,
+    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) => {
+  const nestId = c.req.param("nestId");
+  const nodeId = c.req.param("nodeId");
+  const version = Number(c.req.param("version"));
+  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
+    );
+  }
+  const { versions: versionManager } = await engineCache.get(nestId);
+  try {
+    const raw = await versionManager.reconstructVersion(nodeId, version);
+    return c.json({ version, content: bodyOnly(nodeId, raw) });
+  } catch (err) {
+    console.error("reconstructVersion failed", nestId, nodeId, version, err);
+    return c.json({ version, content: null }, 200);
+  }
+});
 governanceNodeRoutes.get("/:nodeId{.+}/reviews", async (c) => {
   const nestId = c.req.param("nestId");
   const nodeId = c.req.param("nodeId");
@@ -9929,6 +10976,33 @@ governanceNodeRoutes.post("/:nodeId{.+}/submit-review", async (c) => {
     201
   );
 });
+governanceNodeRoutes.post("/:nodeId{.+}/request-deletion", async (c) => {
+  const nestId = c.req.param("nestId");
+  const nodeId = c.req.param("nodeId");
+  const body = await c.req.json().catch(() => ({}));
+  const reason = body.reason?.trim();
+  if (!reason) {
+    throw new ValidationError("A reason for the deletion request is required");
+  }
+  const userEmail = await getUserEmail4(c);
+  if (!await canReadNode(nestId, nodeId, c.get("userId"), userEmail)) {
+    return c.json({ error: `Node not found: ${nodeId}` }, 404);
+  }
+  const { storage } = await engineCache.get(nestId);
+  try {
+    await storage.readDocument(nodeId);
+  } catch {
+    return c.json({ error: `Node not found: ${nodeId}` }, 404);
+  }
+  const request = await requestDeletion({
+    nestId,
+    nodeId,
+    requestedBy: userEmail,
+    reason,
+    baseUrl: requestBaseUrl(c.req.url)
+  });
+  return c.json({ request }, 201);
+});
 governanceNodeRoutes.post(
   "/:nodeId{.+}/external-edits/:suggestionId/approve",
   async (c) => {
@@ -9948,7 +11022,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(
@@ -9983,7 +11059,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);
@@ -10162,6 +11241,49 @@ var flexAuthMiddleware = createMiddleware2(async (c, next) => {
   }
   return c.json({ error: "Missing or invalid credentials" }, 401);
 });
+function nestPathParts(path) {
+  return path.replace(/^\/nests\//, "").split("/").filter(Boolean);
+}
+var flexAuthWithPromptowlTicket = createMiddleware2(
+  async (c, next) => {
+    const header = c.req.header("Authorization") || "";
+    const token = header.startsWith("Bearer ") ? header.slice("Bearer ".length) : "";
+    const secret = config.OFFICIAL_COMMUNITY_SSO_SECRET;
+    const looksLikeJwt = !!token && !token.startsWith("cnst_") && token.split(".").length === 3;
+    if (!looksLikeJwt || !secret) return flexAuthMiddleware(c, next);
+    let claims;
+    try {
+      claims = verifySsoTicket(token, secret);
+    } catch {
+      return c.json({ error: "Invalid service ticket" }, 401);
+    }
+    if (claims.scope !== "mcp" || claims.jti) {
+      return c.json({ error: "Invalid service ticket" }, 401);
+    }
+    const expectedAud = config.PUBLIC_BASE_URL;
+    if (expectedAud && (claims.aud || "").replace(/\/$/, "") !== expectedAud) {
+      return c.json({ error: "Invalid service ticket" }, 401);
+    }
+    const sub = claims.sub.trim();
+    if (!isValidTicketSub(sub)) {
+      return c.json({ error: "Invalid service ticket" }, 401);
+    }
+    const db = getDb();
+    const user = await db.get(
+      "SELECT id FROM users WHERE LOWER(email) = LOWER(?)",
+      [sub]
+    );
+    if (!user) {
+      return c.json(
+        { error: "No ContextNest account exists for this PromptOwl user" },
+        404
+      );
+    }
+    c.set("userId", user.id);
+    c.set("nestScope", null);
+    return next();
+  }
+);
 var APPROVE_CACHE_TTL_MS = 3e4;
 var approveCache = /* @__PURE__ */ new Map();
 async function canApproveInNest(nestId, email) {
@@ -10185,6 +11307,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");
@@ -10837,6 +11966,25 @@ function createApp() {
       requested_at: r.requestedAt,
       priority: r.priority
     });
+    const deletions = await listDeletionRequests({
+      nestIds: [...nestName2.keys()],
+      status: "pending"
+    });
+    const toDeletionItem = (r) => ({
+      type: "deletion",
+      nest_id: r.nestId,
+      nest_name: nestName2.get(r.nestId),
+      node_id: r.nodeId,
+      title: r.title || r.nodeId,
+      requested_by: r.requestedBy,
+      requested_at: r.createdAt,
+      priority: "normal",
+      reason: r.reason,
+      request_id: r.id,
+      // node_id holds a folder path / nest id for those targets, so a client
+      // must not treat it as a document to open.
+      target_type: r.targetType
+    });
     const byNewest = (a, b) => a.requested_at < b.requested_at ? 1 : -1;
     const others = requests.filter((r) => r.requestedBy !== me);
     const nestApprove = new Map(
@@ -10849,8 +11997,27 @@ function createApp() {
         )
       )
     );
-    const items = others.filter((r) => nestApprove.get(r.nestId)).map(toItem).sort(byNewest);
-    const waiting = requests.filter((r) => r.requestedBy === me).map(toItem).sort(byNewest);
+    const items = others.filter((r) => nestApprove.get(r.nestId)).map(toItem);
+    const waiting = requests.filter((r) => r.requestedBy === me).map(toItem);
+    const othersDeletions = deletions.filter((r) => r.requestedBy !== me);
+    const nestManage = new Map(
+      await Promise.all(
+        [...new Set(othersDeletions.map((r) => r.nestId))].map(
+          async (nestId) => {
+            const roles = await resolveUserRoles(nestId, me);
+            return [nestId, roles.includes("owner") || roles.includes("admin")];
+          }
+        )
+      )
+    );
+    items.push(
+      ...othersDeletions.filter((r) => nestManage.get(r.nestId)).map(toDeletionItem)
+    );
+    items.sort(byNewest);
+    waiting.push(
+      ...deletions.filter((r) => r.requestedBy === me).map(toDeletionItem)
+    );
+    waiting.sort(byNewest);
     const notifications = await listNotifications(me, { unreadOnly: true, limit: 50 });
     return c.json({
       items,
@@ -10861,6 +12028,37 @@ function createApp() {
       pagination: { total, limit, offset, has_more: offset + requests.length < total }
     });
   });
+  app.get("/me/drafts", async (c) => {
+    const userId = c.get("userId");
+    const me = await resolveCallerEmail(userId);
+    const nestName2 = /* @__PURE__ */ new Map();
+    for (const n of await listVisibleNests(userId))
+      nestName2.set(n.id, n.name ?? n.id);
+    const limit = Math.min(Math.max(Number(c.req.query("limit")) || 25, 1), 100);
+    const offset = Math.max(Number(c.req.query("offset")) || 0, 0);
+    const { drafts, total } = await listMyDrafts({
+      authorEmail: me,
+      nestIds: [...nestName2.keys()],
+      limit,
+      offset
+    });
+    return c.json({
+      drafts: drafts.map((d) => ({
+        nest_id: d.nestId,
+        nest_name: nestName2.get(d.nestId),
+        node_id: d.nodeId,
+        title: d.title,
+        // Where it actually lives — the thing that was impossible to find.
+        folder: folderForNode(d.nodeId),
+        status: d.status,
+        version: d.version,
+        updated_at: d.updatedAt
+      })),
+      // has_more off the REQUESTED page size, not the returned row count: the
+      // existence filter can shorten a page, and that must not read as "last".
+      pagination: { total, limit, offset, has_more: offset + limit < total }
+    });
+  });
   app.get("/me/notifications", async (c) => {
     const me = await resolveCallerEmail(c.get("userId"));
     const unreadOnly = c.req.query("unread") === "true";
@@ -10896,19 +12094,54 @@ 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)).map(async (nest) => {
+        try {
+          const { storage } = await engineCache.get(nest.id);
+          const matches = matchDocuments(await storage.discoverDocuments(), q);
+          if (matches.length === 0) return [];
+          const accessible = await filterAccessible(nest.id, userId, userEmail, matches);
+          return accessible.map((n) => ({
+            ...toSearchHit(n),
+            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();
+    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);
   app.route("/llms.txt", llmsTxtRoutes);
-  app.use("/index", flexAuthMiddleware);
+  app.use("/index", flexAuthWithPromptowlTicket);
   app.route("/index", nestIndexRoutes);
-  app.use("/mcp", flexAuthMiddleware);
+  app.use("/mcp", flexAuthWithPromptowlTicket);
   app.route("/mcp", serverMcpRoutes);
   const nestsApp = new Hono21();
-  nestsApp.use("*", flexAuthMiddleware);
   nestsApp.use("*", async (c, next) => {
-    const localPath = c.req.path.replace(/^\/nests\//, "");
-    const parts = localPath.split("/").filter(Boolean);
+    const parts = nestPathParts(c.req.path);
+    const ticketEligible = parts.length === 2 && (c.req.method === "POST" && parts[1] === "context" || c.req.method === "GET" && parts[1] === "nodes" || parts[1] === "mcp");
+    return ticketEligible ? flexAuthWithPromptowlTicket(c, next) : flexAuthMiddleware(c, next);
+  });
+  nestsApp.use("*", async (c, next) => {
+    const parts = nestPathParts(c.req.path);
     if (parts.length < 2) return next();
     if (parts[0] === "unsynced") return next();
     const nestId = parts[0];
@@ -10945,7 +12178,8 @@ function createApp() {
       const isCommentPath = /\/comments$/.test(path2) || /\/comments\/[^/]+\/resolve$/.test(path2);
       const isActivityPath = /\/activity$/.test(path2);
       const isFeedPath = parts.length === 2 && parts[1] === "feed";
-      const isGovernance = path2.includes("/stewards") || path2.includes("/review-queue") || path2.includes("/versions") || path2.includes("/reviews") || path2.includes("/submit-review") || path2.includes("/cancel-review") || path2.includes("/approve") || path2.includes("/reject") || path2.includes("/can-access") || path2.includes("/can-approve") || path2.includes("/can-edit") || isCommentPath || isActivityPath || isFeedPath;
+      const isDeletionQueuePath = parts.length === 2 && parts[1] === "deletion-requests";
+      const isGovernance = path2.includes("/stewards") || path2.includes("/review-queue") || path2.includes("/versions") || path2.includes("/reviews") || path2.includes("/submit-review") || path2.includes("/cancel-review") || path2.includes("/approve") || path2.includes("/reject") || path2.includes("/can-access") || path2.includes("/can-approve") || path2.includes("/can-edit") || isCommentPath || isActivityPath || isFeedPath || isDeletionQueuePath;
       const needsLicense = c.req.method !== "GET" || isGovernance;
       if (needsLicense) {
         const lic = getCurrentLicense();
@@ -10991,6 +12225,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 isStewardRoster = path.includes("/stewards") && !path.includes("/nodes/");
     if (isStewardRoster && permission !== "owner" && permission !== "admin") {
       return c.json(
@@ -11009,7 +12244,7 @@ function createApp() {
       required = c.req.method === "GET" ? "write" : "admin";
     } else if (parts[1] === "hooks") {
       required = "write";
-    } else if (c.req.method !== "GET" && !isStewardActionPath && !isCommentAction && !isAnnotationAction && !isReadQuery && !isMcpTransport) {
+    } else if (c.req.method !== "GET" && !isStewardActionPath && !isCommentAction && !isDeletionRequestAction && !isAnnotationAction && !isReadQuery && !isMcpTransport) {
       required = "write";
     }
     const isNodeAction = c.req.method === "POST" && parts.length >= 4 && (parts[parts.length - 1] === "revert" || parts[parts.length - 1] === "move");
@@ -11102,6 +12337,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({
@@ -11109,14 +12345,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);
@@ -11289,6 +12531,111 @@ async function backfillNodeVersionsFromHistory(db) {
     `[backfill] node_versions: scanned ${totalDocs} docs across ${nests.length} nests, inserted ${totalInserted} rows`
   );
 }
+var NOTIFICATION_TITLES_MIGRATION_ID = "006_backfill_notification_titles";
+async function backfillNotificationTitles(db) {
+  const already = await db.get(
+    "SELECT id FROM schema_migrations WHERE id = ?",
+    [NOTIFICATION_TITLES_MIGRATION_ID]
+  );
+  if (already) return;
+  const rows = await db.all(
+    "SELECT id, nest_id, message FROM notifications WHERE message LIKE '%nodes/%'"
+  );
+  let rewritten = 0;
+  if (rows.length > 0) {
+    const titlesByNest = /* @__PURE__ */ new Map();
+    for (const nestId of new Set(rows.map((r) => r.nest_id))) {
+      titlesByNest.set(nestId, await buildTitleMap(nestId));
+    }
+    for (const row of rows) {
+      const titles = titlesByNest.get(row.nest_id) ?? /* @__PURE__ */ new Map();
+      const next = row.message.replace(
+        /"([^"]*nodes\/[^"]*)"/g,
+        (whole, id) => {
+          const label = describeNodeWith(titles, id);
+          return `"${label.replace(/"/g, "")}"`;
+        }
+      );
+      if (next === row.message) continue;
+      await db.run("UPDATE notifications SET message = ? WHERE id = ?", [
+        next,
+        row.id
+      ]);
+      rewritten++;
+    }
+  }
+  await db.run(
+    insertOrIgnore(db, "INSERT INTO schema_migrations (id) VALUES (?)"),
+    [NOTIFICATION_TITLES_MIGRATION_ID]
+  );
+  console.log(
+    `[backfill] notifications: rewrote ${rewritten} of ${rows.length} message(s) carrying a node id`
+  );
+}
+function describeNodeWith(titles, nodeId) {
+  const at = nodeId.indexOf("nodes/");
+  const normalized = at > 0 ? nodeId.slice(at) : nodeId;
+  const title = titles.get(nodeId) || titles.get(normalized) || normalized.split("/").pop() || nodeId;
+  const folder = folderForNode(normalized);
+  return folder ? `${title} (in ${folder})` : title;
+}
+
+// src/db/repair-version-chains.ts
+var MIGRATION_ID2 = "010_repair_grafted_version_chains";
+async function repairGraftedVersionChains(db) {
+  const already = await db.get("SELECT id FROM schema_migrations WHERE id = ?", [
+    MIGRATION_ID2
+  ]);
+  if (already) return;
+  const nests = await db.all("SELECT id FROM nests");
+  let scanned = 0;
+  let repaired = 0;
+  let externalized = 0;
+  for (const { id: nestId } of nests) {
+    let storage;
+    let versions;
+    try {
+      ({ storage, versions } = await engineCache.get(nestId));
+    } catch (err) {
+      console.warn(
+        `[repair] engine unavailable for nest ${nestId}:`,
+        err.message
+      );
+      continue;
+    }
+    let docs;
+    try {
+      docs = await storage.discoverDocuments();
+    } catch (err) {
+      console.warn(
+        `[repair] discoverDocuments failed for nest ${nestId}:`,
+        err.message
+      );
+      continue;
+    }
+    for (const doc of docs) {
+      scanned += 1;
+      try {
+        if (await versions.repairLatestVersion(doc.id)) {
+          repaired += 1;
+          console.log(`[repair] re-anchored version chain: ${nestId}/${doc.id}`);
+        }
+        externalized += await versions.externalizeDiffs(doc.id);
+      } catch (err) {
+        console.warn(
+          `[repair] could not repair ${nestId}/${doc.id}:`,
+          err.message
+        );
+      }
+    }
+  }
+  await db.run(insertOrIgnore(db, "INSERT INTO schema_migrations (id) VALUES (?)"), [
+    MIGRATION_ID2
+  ]);
+  console.log(
+    `[repair] version chains: scanned ${scanned} docs across ${nests.length} nests, re-anchored ${repaired}, externalized ${externalized} inline change log(s)`
+  );
+}
 
 // src/workflow/scheduler.ts
 import { v4 as uuid15 } from "uuid";
@@ -11366,6 +12713,16 @@ async function main() {
   } catch (err) {
     console.error("[backfill] node_versions backfill failed:", err);
   }
+  try {
+    await repairGraftedVersionChains(db);
+  } catch (err) {
+    console.error("[repair] version chain repair failed:", err);
+  }
+  try {
+    await backfillNotificationTitles(db);
+  } catch (err) {
+    console.error("[backfill] notification title backfill failed:", err);
+  }
   const accessCfg = loadAccessConfig();
   if (accessCfg) {
     console.log(`  Loaded access.yaml (mode: ${accessCfg.mode || "open"})`);
@@ -11437,6 +12794,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