@promptowl/contextnest-community 1.17.0 → 1.19.0

package/dist/index.js

@@ -41,7 +41,27 @@ import {
   submitForReview,
   withNodeWriteLock,
   withdrawDeletionRequest
-} from "./chunk-4YGJSUJC.js";
+} from "./chunk-FBDEESNJ.js";
+import {
+  canCreateInNest,
+  canManageStewards,
+  canUserAccess,
+  canUserApprove,
+  canUserEdit,
+  createStewardRecord,
+  getCollaboratorRole,
+  getStewardRolesForUser,
+  getStewardsForNest,
+  getStewardsForUser,
+  listStewards,
+  removeSteward,
+  resolveGrantRoles,
+  resolveStewardsForNode,
+  resolveStewardsWithFallback,
+  resolveUserRoles,
+  syncFromConfig,
+  updateSteward
+} from "./chunk-3GMGLYTZ.js";
 import {
   createGrant,
   deleteGrant,
@@ -50,15 +70,16 @@ import {
   listGrants,
   listUserGrants,
   resolveNodeGrant
-} from "./chunk-HWDPCPYT.js";
+} from "./chunk-GSYMJ3A4.js";
 import {
   generateApiKey,
   getKeyPrefix,
   hashApiKey,
   hashPassword,
   parseBearerToken,
+  verifyKeyRequest,
   verifyPassword
-} from "./chunk-XRK6SQSC.js";
+} from "./chunk-F66VCBLA.js";
 import {
   checkConflict,
   createVersion,
@@ -66,36 +87,32 @@ import {
   getApprovedVersions,
   getCurrentVersion,
   getDisplayStatus,
+  getDisplayStatuses,
   getTrackedNodeIds,
   getVersions,
   listMyDrafts,
   setApprovedVersion,
   upsertVersion
-} from "./chunk-UXJSO54R.js";
+} from "./chunk-BXUVIAMP.js";
 import {
-  canCreateInNest,
-  canManageStewards,
-  canUserAccess,
-  canUserApprove,
-  canUserEdit,
-  createStewardRecord,
-  getCollaboratorRole,
-  getStewardRolesForUser,
-  getStewardsForNest,
-  getStewardsForUser,
-  listStewards,
-  removeSteward,
-  resolveGrantRoles,
-  resolveStewardsForNode,
-  resolveStewardsWithFallback,
-  resolveUserRoles,
-  syncFromConfig,
-  updateSteward
-} from "./chunk-YF4OFT2V.js";
+  approveExternalEdit,
+  getExternalEditDetail,
+  getPendingChange,
+  listExternalEditVerdicts,
+  listNestExternalEdits,
+  loadLatestApprovedNode,
+  rejectExternalEdit,
+  scanDocumentForDrift,
+  scanNestForDrift,
+  startDriftScanner
+} from "./chunk-TNAZJYL5.js";
 import {
   addMember,
+  assertSafeNodeId,
   buildTitleMap,
   canApproveWith,
+  canEditWith,
+  collabPermToRole,
   createNest,
   createTeam,
   deleteNest,
@@ -104,14 +121,17 @@ import {
   docLink,
   engineApi,
   engineCache,
+  ensureNodeIndex,
   findTeamByExternalId,
   folderForNode,
+  folderOfId,
   getAccessConfig,
   getCurrentLicense,
   getNest,
   getSuspensionReason,
   getTeam,
   importNest,
+  indexedFolderCounts,
   insertOrIgnore,
   installLicenseKey,
   isConfigSuperAdmin,
@@ -136,11 +156,15 @@ import {
   nestPrimeTags,
   nestReviewsPrimeOnly,
   nestStorageRoot,
+  nodesWithSuggestions,
   normalizeTag,
   nowExpr,
   opContext,
   permissionLevel,
   persistSetting,
+  primaryRole,
+  readIndexedNodes,
+  rebuildNodeIndex,
   removeMember,
   removeNodeFromTagIndex,
   renameNest,
@@ -150,6 +174,8 @@ import {
   resolveNestAccess,
   resolveNestPath,
   resolveNestPermission,
+  resolveNodeUrl,
+  resolveTeamRolesForUser,
   sendEmailToRecipient,
   setAllowSelfApprove,
   setPrimeOnlyReview,
@@ -165,7 +191,7 @@ import {
   updateMemberRole,
   validateLicense,
   verifySmtp
-} from "./chunk-SNFGU5Q7.js";
+} from "./chunk-ENDHMQPD.js";
 import {
   AppError,
   ConflictError,
@@ -173,19 +199,22 @@ import {
   LockedError,
   NotFoundError,
   UnauthorizedError,
-  ValidationError
-} from "./chunk-GUNJTORH.js";
+  ValidationError,
+  VaultBusyError,
+  isVaultLockTimeout
+} from "./chunk-YVMSM7LS.js";
 import {
   config,
   getDb,
   initDb,
   isEmailListish,
   isEmailish
-} from "./chunk-JMJLNEXE.js";
+} from "./chunk-HYSTFMFG.js";
 import {
   ANON_EMAIL,
-  ANON_USER_ID
-} from "./chunk-SLTQACJW.js";
+  ANON_USER_ID,
+  MAX_FOLDER_DEPTH
+} from "./chunk-YB3LKF7U.js";
 import {
   normalizeEmail
 } from "./chunk-FRQJWGN3.js";
@@ -1079,19 +1108,11 @@ authRoutes.post("/keys", authMiddleware, async (c) => {
   );
   const db = getDb();
   const userId = c.get("userId");
-  const existing = await db.get(
-    "SELECT key_prefix FROM api_keys WHERE user_id = ?",
-    [userId]
-  );
-  if (existing) {
-    return c.json(
-      {
-        error: "An API key already exists for this user. Rotate it instead.",
-        key_prefix: existing.key_prefix
-      },
-      409
-    );
-  }
+  const check = await verifyKeyRequest(db, userId, {
+    action: "generate",
+    label: body.label
+  });
+  if (!check.ok) return c.json({ error: check.error }, check.status);
   const apiKey = generateApiKey();
   const keyId = uuid2();
   await db.run(
@@ -1102,11 +1123,11 @@ authRoutes.post("/keys", authMiddleware, async (c) => {
       hashApiKey(apiKey),
       getKeyPrefix(apiKey),
       body.nest_id || null,
-      body.label || null
+      check.label
     ]
   );
   return c.json(
-    { api_key: apiKey, key_prefix: getKeyPrefix(apiKey) },
+    { id: keyId, api_key: apiKey, key_prefix: getKeyPrefix(apiKey), label: check.label },
     201
   );
 });
@@ -1114,15 +1135,22 @@ authRoutes.post("/keys/rotate", authMiddleware, async (c) => {
   const body = await c.req.json().catch(() => ({}));
   const db = getDb();
   const userId = c.get("userId");
+  const check = await verifyKeyRequest(db, userId, {
+    action: "update",
+    label: body.label,
+    keyId: body.key_id
+  });
+  if (!check.ok) return c.json({ error: check.error }, check.status);
+  const prior = check.key;
   const apiKey = generateApiKey();
   const keyId = uuid2();
-  const prior = await db.get(
-    "SELECT label, nest_id FROM api_keys WHERE user_id = ?",
-    [userId]
-  );
-  const nestScope = "nest_id" in body ? body.nest_id || null : prior?.nest_id ?? null;
-  await db.transaction(async (tx) => {
-    await tx.run("DELETE FROM api_keys WHERE user_id = ?", [userId]);
+  const nestScope = "nest_id" in body ? body.nest_id || null : prior.nest_id;
+  const replaced = await db.transaction(async (tx) => {
+    const removed = await tx.run(
+      "DELETE FROM api_keys WHERE id = ? AND user_id = ?",
+      [prior.id, userId]
+    );
+    if (removed.changes === 0) return false;
     await tx.run(
       "INSERT INTO api_keys (id, user_id, key_hash, key_prefix, nest_id, label) VALUES (?, ?, ?, ?, ?, ?)",
       [
@@ -1131,29 +1159,47 @@ authRoutes.post("/keys/rotate", authMiddleware, async (c) => {
         hashApiKey(apiKey),
         getKeyPrefix(apiKey),
         nestScope,
-        body.label ?? prior?.label ?? null
+        check.label ?? prior.label
       ]
     );
+    return true;
+  });
+  if (!replaced) {
+    return c.json(
+      { error: "That key no longer exists \u2014 reload and try again." },
+      404
+    );
+  }
+  return c.json({
+    id: keyId,
+    api_key: apiKey,
+    key_prefix: getKeyPrefix(apiKey),
+    label: check.label ?? prior.label
   });
-  return c.json({ api_key: apiKey, key_prefix: getKeyPrefix(apiKey) });
 });
 authRoutes.get("/keys", authMiddleware, async (c) => {
   const db = getDb();
+  const userId = c.get("userId");
+  const check = await verifyKeyRequest(db, userId, { action: "fetch" });
+  if (!check.ok) return c.json({ error: check.error }, check.status);
   const keys = await db.all(
-    "SELECT id, key_prefix, nest_id, label, created_at, last_used_at FROM api_keys WHERE user_id = ?",
-    [c.get("userId")]
+    "SELECT id, key_prefix, nest_id, label, created_at, last_used_at FROM api_keys WHERE user_id = ? ORDER BY created_at ASC, id ASC",
+    [userId]
   );
   return c.json({ keys });
 });
 authRoutes.delete("/keys/:keyId", authMiddleware, async (c) => {
   const db = getDb();
-  const result = await db.run(
-    "DELETE FROM api_keys WHERE id = ? AND user_id = ?",
-    [c.req.param("keyId"), c.get("userId")]
-  );
-  if (result.changes === 0) {
-    return c.json({ error: "Key not found" }, 404);
-  }
+  const userId = c.get("userId");
+  const check = await verifyKeyRequest(db, userId, {
+    action: "update",
+    keyId: c.req.param("keyId")
+  });
+  if (!check.ok) return c.json({ error: check.error }, check.status);
+  await db.run("DELETE FROM api_keys WHERE id = ? AND user_id = ?", [
+    check.key.id,
+    userId
+  ]);
   return c.json({ deleted: true });
 });
 authRoutes.post("/device", async (c) => {
@@ -1610,19 +1656,18 @@ import { Hono as Hono3 } from "hono";
 
 // src/nodes/service.ts
 import {
-  parseDocument as parseDocument2,
+  parseDocument,
   normalizeStatus,
   isRejected,
-  DocumentNotFoundError
+  filterDocuments,
+  DocumentNotFoundError,
+  NODE_TYPES
 } from "@promptowl/contextnest-engine";
 import { rename, mkdir } from "fs/promises";
-import { dirname, join as join2 } from "path";
+import { dirname, join } from "path";
 
 // src/governance/safe-publish.ts
-import {
-  publishDocument,
-  serializeDocument
-} from "@promptowl/contextnest-engine";
+import { serializeDocument } from "@promptowl/contextnest-engine";
 function serializeNodeSafe(node) {
   return serializeDocument({
     ...node,
@@ -1644,6 +1689,9 @@ function stripUndefinedDeep(value) {
   return value;
 }
 
+// src/nodes/service.ts
+import { inputJsonSchema } from "@promptowl/contextnest-engine/api";
+
 // src/governance/prime-service.ts
 async function isPrimeDocument(nestId, tags, metadata) {
   const flag = documentPrimeFlag(metadata);
@@ -1661,313 +1709,6 @@ function documentPrimeFlag(metadata) {
   return void 0;
 }
 
-// src/governance/external-edit-service.ts
-import { readFile } from "fs/promises";
-import { join } from "path";
-import {
-  detectDrift,
-  stageSuggestion,
-  ChainEventLog,
-  approveSuggestion,
-  rejectSuggestion,
-  listSuggestions,
-  readSuggestion,
-  parseDocument,
-  VersionManager,
-  computeContentHash,
-  getChecksumContent
-} from "@promptowl/contextnest-engine";
-var communityRbac = {
-  isCzar: () => false,
-  canIngest: () => true,
-  isDocOwner: () => true
-};
-function docPath(nestId, documentId) {
-  return join(resolveNestPath(nestId), `${documentId}.md`);
-}
-async function readRaw(nestId, documentId) {
-  try {
-    return await readFile(docPath(nestId, documentId), "utf-8");
-  } catch {
-    return null;
-  }
-}
-async function loadChainHead(storage, documentId) {
-  const history = await storage.readHistory(documentId);
-  if (!history || history.versions.length === 0) return null;
-  const latest = history.versions[history.versions.length - 1];
-  try {
-    const content = await new VersionManager(storage).reconstructVersion(
-      documentId,
-      latest.version
-    );
-    return { version: latest.version, content };
-  } catch {
-    return null;
-  }
-}
-async function loadLatestApprovedNode(nestId, documentId) {
-  const { storage } = await engineCache.get(nestId);
-  const head = await loadChainHead(storage, documentId);
-  if (!head) return null;
-  return parseDocument(docPath(nestId, documentId), head.content, documentId);
-}
-async function bodyMatchesLatestVersion(storage, documentId, liveBodyHash) {
-  const head = await loadChainHead(storage, documentId);
-  if (!head) return false;
-  const headBodyHash = computeContentHash(getChecksumContent(head.content));
-  return headBodyHash === liveBodyHash;
-}
-async function scanDocumentForDrift(nestId, documentId, actor = "system:scanner") {
-  const res = await scanDocumentForDriftInternal(nestId, documentId, actor);
-  return res?.meta ?? null;
-}
-async function scanDocumentForDriftInternal(nestId, documentId, actor) {
-  const { storage } = await engineCache.get(nestId);
-  const node = await storage.readDocument(documentId).catch(() => null);
-  if (!node) return null;
-  const raw = await readRaw(nestId, documentId);
-  if (raw == null) return null;
-  const drift = detectDrift(raw, node.frontmatter.checksum);
-  if (!drift.drifted) return null;
-  if (await bodyMatchesLatestVersion(storage, documentId, drift.actualHash)) {
-    return null;
-  }
-  const approved = await loadChainHead(storage, documentId);
-  if (!approved) return null;
-  const existing = await listSuggestions(storage, documentId);
-  const dup = existing.find((s) => s.proposed_hash === drift.actualHash);
-  if (dup) return { meta: dup, created: false };
-  const result = await stageSuggestion({
-    storage,
-    documentId,
-    approvedRawContent: approved.content,
-    proposedRawContent: raw,
-    source: "out-of-band-edit",
-    actor,
-    docTier: "standard"
-  });
-  return { meta: result.meta, created: true };
-}
-async function scanNestForDrift(nestId, actor = "system:scanner") {
-  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))
-  );
-  const staged = results.filter((r) => r?.created).length;
-  return { scanned: docs.length, staged };
-}
-async function getPendingChange(nestId, documentId) {
-  const { storage } = await engineCache.get(nestId);
-  const list = await listSuggestions(storage, documentId);
-  for (let i = list.length - 1; i >= 0; i--) {
-    const meta = list[i];
-    if (await bodyMatchesLatestVersion(storage, documentId, meta.proposed_hash)) {
-      continue;
-    }
-    return {
-      suggestion_id: meta.suggestion_id,
-      detected_at: meta.detected_at,
-      source: meta.source,
-      proposed_hash: meta.proposed_hash
-    };
-  }
-  return null;
-}
-async function listNestExternalEdits(nestId) {
-  const { storage } = await engineCache.get(nestId);
-  const docs = await storage.discoverDocuments();
-  const lists = await Promise.all(
-    docs.map(async (doc) => {
-      const metas = await listSuggestions(storage, doc.id);
-      const fresh = [];
-      for (const meta of metas) {
-        if (await bodyMatchesLatestVersion(storage, doc.id, meta.proposed_hash)) {
-          continue;
-        }
-        fresh.push(meta);
-      }
-      return fresh;
-    })
-  );
-  const entries = lists.flat().map((meta) => ({
-    suggestion_id: meta.suggestion_id,
-    nest_id: nestId,
-    document_id: meta.document_id,
-    source: meta.source,
-    detected_at: meta.detected_at,
-    actor: meta.actor,
-    target_hash: meta.target_hash,
-    proposed_hash: meta.proposed_hash,
-    note: meta.note
-  }));
-  return entries.sort((a, b) => b.detected_at.localeCompare(a.detected_at));
-}
-async function getExternalEditDetail(nestId, documentId, suggestionId) {
-  const { storage } = await engineCache.get(nestId);
-  const found = await readSuggestion(storage, documentId, suggestionId);
-  if (!found) return null;
-  return {
-    suggestion_id: found.meta.suggestion_id,
-    nest_id: nestId,
-    document_id: found.meta.document_id,
-    source: found.meta.source,
-    detected_at: found.meta.detected_at,
-    actor: found.meta.actor,
-    target_hash: found.meta.target_hash,
-    proposed_hash: found.meta.proposed_hash,
-    note: found.meta.note,
-    patch: found.patch
-  };
-}
-async function recordVerdict(nestId, event) {
-  try {
-    const { storage } = await engineCache.get(nestId);
-    await new ChainEventLog(storage).append(event);
-    return true;
-  } catch (err) {
-    console.error(
-      `[external-edit] failed to record verdict ${event.event_id} for nest ${nestId}:`,
-      err
-    );
-    return false;
-  }
-}
-async function listExternalEditVerdicts(nestId, documentId) {
-  try {
-    const { storage } = await engineCache.get(nestId);
-    const events = await new ChainEventLog(storage).readByDocument(documentId);
-    return events.flatMap((e) => {
-      const meta = e.action_metadata || {};
-      if (typeof meta.suggestion_id !== "string") return [];
-      const reason = meta.rejection_reason;
-      const comment = meta.approval_comment;
-      return [
-        {
-          suggestion_id: meta.suggestion_id,
-          status: typeof reason === "string" ? "rejected" : "approved",
-          actor: e.actor,
-          at: e.timestamp,
-          note: typeof reason === "string" ? reason : typeof comment === "string" ? comment : void 0,
-          source: typeof meta.source === "string" ? meta.source : void 0
-        }
-      ];
-    });
-  } catch (err) {
-    console.error(
-      `[external-edit] failed to read verdicts for ${nestId}/${documentId}:`,
-      err
-    );
-    return [];
-  }
-}
-async function mirrorVersion(input) {
-  const { storage } = await engineCache.get(input.nestId);
-  const node = await storage.readDocument(input.documentId);
-  const { upsertVersion: upsertVersion2, setApprovedVersion: setApprovedVersion2 } = await import("./version-service-EFZGGL3Y.js");
-  await upsertVersion2({
-    nestId: input.nestId,
-    nodeId: input.documentId,
-    version: input.version,
-    content: node.body || "",
-    author: input.actor,
-    status: "published",
-    tags: node.frontmatter.tags || [],
-    changeNote: input.note
-  });
-  await setApprovedVersion2(
-    input.nestId,
-    input.documentId,
-    input.version,
-    input.actor
-  );
-}
-async function approveExternalEdit(input) {
-  const { storage } = await engineCache.get(input.nestId);
-  let result;
-  try {
-    result = await approveSuggestion({
-      storage,
-      rbac: communityRbac,
-      documentId: input.documentId,
-      suggestionId: input.suggestionId,
-      actor: input.actor,
-      zone: "default",
-      comment: input.comment
-    });
-  } catch (err) {
-    console.error(
-      `[external-edit] approveSuggestion failed for ${input.nestId}/${input.documentId} suggestion=${input.suggestionId}:`,
-      err
-    );
-    throw err;
-  }
-  try {
-    await mirrorVersion({
-      nestId: input.nestId,
-      documentId: input.documentId,
-      version: result.versionEntry.version,
-      actor: input.actor,
-      note: input.comment ? `External edit approved: ${input.comment}` : "External edit approved"
-    });
-  } catch (err) {
-    console.error(
-      `[external-edit] failed to mirror approved version into node_versions for ${input.nestId}/${input.documentId}:`,
-      err
-    );
-  }
-  const historyRecorded = await recordVerdict(input.nestId, result.chainEvent);
-  return { ...result, historyRecorded };
-}
-async function rejectExternalEdit(input) {
-  const { storage } = await engineCache.get(input.nestId);
-  const result = await rejectSuggestion({
-    storage,
-    rbac: communityRbac,
-    documentId: input.documentId,
-    suggestionId: input.suggestionId,
-    actor: input.actor,
-    zone: "default",
-    reason: input.reason
-  });
-  const historyRecorded = await recordVerdict(input.nestId, result.chainEvent);
-  try {
-    const approved = await loadChainHead(storage, input.documentId);
-    if (approved) {
-      await storage.writeDocument(input.documentId, approved.content);
-    }
-  } catch (err) {
-    console.error(
-      `[external-edit] revert-on-reject failed for ${input.nestId}/${input.documentId}:`,
-      err
-    );
-  }
-  return { ...result, historyRecorded };
-}
-var scannerTimer = null;
-async function scanAllNests() {
-  const db = getDb();
-  const rows = await db.all("SELECT id FROM nests");
-  await Promise.all(
-    rows.map(
-      ({ id }) => scanNestForDrift(id).catch(
-        (err) => console.error(`[external-edit] scan failed for nest ${id}:`, err)
-      )
-    )
-  );
-}
-function startDriftScanner(intervalMs = 3e4) {
-  if (scannerTimer) return;
-  scannerTimer = setInterval(() => {
-    scanAllNests().catch(
-      (err) => console.error("[external-edit] scanner tick failed:", err)
-    );
-  }, intervalMs);
-  scannerTimer.unref?.();
-}
-
 // src/nodes/service.ts
 async function userIdFromEmail(email) {
   const db = getDb();
@@ -1986,17 +1727,42 @@ function assertTitleLength(title) {
     );
   }
 }
-function assertTitleSluggable(title) {
-  if (!slugify(title)) {
+function assertTitleReadable(title) {
+  if (!/[\p{L}\p{N}]/u.test(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"
+      "the title needs at least one letter or number \u2014 it is what search and wiki links read back"
     );
   }
 }
-var slugify = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+var slugify = (s) => s.normalize("NFKD").replace(/\p{M}+/gu, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+async function generatedSlug(storage, prefix) {
+  for (let n = 1; n <= 1e3; n++) {
+    const slug = `document-${n}`;
+    try {
+      await storage.readDocument(`${prefix}${slug}`);
+    } catch (err) {
+      if (err instanceof DocumentNotFoundError) return slug;
+      throw err;
+    }
+  }
+  throw new ValidationError(
+    "too many generated document ids in this folder \u2014 give the document a title with Latin letters or digits, or file it elsewhere"
+  );
+}
 function isIdUnderFolder(id, folder) {
   return id.startsWith(`nodes/${folder}/`) || id.startsWith(`${folder}/`);
 }
+function assertSafeFolder(folder) {
+  if (folder.split(/[/\\]/).some((seg) => seg === "..")) {
+    throw new ValidationError(
+      `Invalid folder "${folder}": path traversal ("..") is not allowed.`
+    );
+  }
+}
+async function storagePrefix(nestId) {
+  const { storage } = await engineCache.get(nestId);
+  return await storage.detectLayout() === "structured" ? "nodes" : "";
+}
 function folderToSegments(folder) {
   const segments = folder.split("/").map(slugify).filter(Boolean);
   if (folder.trim() && segments.length === 0) {
@@ -2005,8 +1771,10 @@ function folderToSegments(folder) {
     );
   }
   if (segments[0] === "nodes") segments.shift();
-  if (segments.length > 8) {
-    throw new ValidationError("folder may nest at most 8 levels deep");
+  if (segments.length > MAX_FOLDER_DEPTH) {
+    throw new ValidationError(
+      `folder may nest at most ${MAX_FOLDER_DEPTH} levels deep`
+    );
   }
   if (segments.some((seg) => seg.length > 100)) {
     throw new ValidationError(
@@ -2037,12 +1805,16 @@ function toSafeError(err, context, message) {
       "This document is rejected. Change its status before saving."
     );
   }
+  if (isVaultLockTimeout(err)) {
+    console.error(`${context}:`, err);
+    return new VaultBusyError();
+  }
   console.error(`${context}:`, err);
   return new AppError(500, message);
 }
 function bodyOnly(nodeId, raw) {
   try {
-    return parseDocument2(`${nodeId}.md`, raw, nodeId).body ?? "";
+    return parseDocument(`${nodeId}.md`, raw, nodeId).body ?? "";
   } catch {
     return raw;
   }
@@ -2051,6 +1823,12 @@ var RUNNABLE_NODE_TYPES = ["agent", "skill"];
 function isRunnableType(type) {
   return RUNNABLE_NODE_TYPES.includes(type || "");
 }
+var ACCEPTED_NODE_TYPES = /* @__PURE__ */ new Set([
+  ...NODE_TYPES,
+  ...RUNNABLE_NODE_TYPES,
+  "artifact",
+  "table"
+]);
 function toNodeResponse(node) {
   const fm = node.frontmatter;
   const title = fm.title === void 0 || fm.title === null ? "" : String(fm.title);
@@ -2127,6 +1905,15 @@ async function resolveAuthorship(nestId, nodes) {
   }
   return result;
 }
+var folderScopeSupported = null;
+function engineScopesFolders() {
+  if (folderScopeSupported === null) {
+    const op = engineApi.getOperation("context_list");
+    const properties = op ? inputJsonSchema(op).properties ?? {} : {};
+    folderScopeSupported = "folder" in properties;
+  }
+  return folderScopeSupported;
+}
 async function getNodeForCaller(nestId, selector, userId, userEmail, opts = {}) {
   if (selector.id && !await canReadNode(nestId, selector.id, userId, userEmail)) {
     throw new ForbiddenError(
@@ -2168,29 +1955,52 @@ async function getNodeForCaller(nestId, selector, userId, userEmail, opts = {})
   };
 }
 async function listNodesForCaller(nestId, userId, filters = {}) {
+  if (filters.folder !== void 0) assertSafeFolder(filters.folder);
   const { versions: versionManager } = await engineCache.get(nestId);
   const userEmail = await resolveCallerEmail(userId);
-  const { documents } = await engineApi.run(
-    "context_list",
-    {
-      ...filters.type ? { type: filters.type } : {},
-      ...filters.tag ? { tag: filters.tag } : {},
-      ...filters.status ? { status: filters.status } : {},
-      // Unlike the CLI and mcp-server, a retired node stays in this listing:
-      // here it is an unpublished document its stewards may still need to act
-      // on, not one removed from retrieval. An imported vault carrying
-      // `status: rejected` registers exactly that way.
-      include_retired: true,
-      full: true
-    },
-    await opContext(nestId, userEmail)
-  );
-  const nodes = documents.map((d) => ({
+  const listFilters = {
+    ...filters.type ? { type: filters.type } : {},
+    ...filters.tag ? { tag: filters.tag } : {},
+    ...filters.status ? { status: filters.status } : {}
+  };
+  const frontmatterFilters = { ...listFilters, includeRetired: true };
+  let documents;
+  if (filters.withContent) {
+    const scopeInEngine = filters.folder !== void 0 && engineScopesFolders();
+    const scopePrefix = scopeInEngine ? await storagePrefix(nestId) : "";
+    ({ documents } = await engineApi.run(
+      "context_list",
+      {
+        ...listFilters,
+        include_retired: true,
+        ...scopeInEngine ? {
+          folder: [scopePrefix, filters.folder].filter(Boolean).join("/"),
+          recursive: false
+        } : {},
+        full: true
+      },
+      await opContext(nestId, userEmail)
+    ));
+  } else {
+    await ensureNodeIndex(nestId);
+    const indexed = await readIndexedNodes(
+      nestId,
+      filters.folder !== void 0 ? { folder: filters.folder } : {}
+    );
+    documents = filterDocuments(indexed, {
+      ...frontmatterFilters,
+      includeRetired: true
+    });
+  }
+  const scoped = filters.folder === void 0 ? documents : documents.filter((d) => folderOfId(d.id) === filters.folder);
+  const nodes = scoped.map((d) => ({
     id: d.id,
     filePath: "",
     rawContent: "",
     frontmatter: d.frontmatter,
-    body: d.body
+    // Empty on the indexed path: no listing renders a body, and the
+    // approved-only branch below serves its own from the version store.
+    body: d.body ?? ""
   }));
   const publicReader = await isPublicReader(nestId, userId);
   const approvedOnly = publicReader || filters.approvedOnly === true;
@@ -2207,6 +2017,13 @@ async function listNodesForCaller(nestId, userId, filters = {}) {
     accessible = accessible.filter((d) => approvedVersions.has(d.id));
   }
   if (filters.limit) accessible = accessible.slice(0, filters.limit);
+  const [displayStatuses, driftedDocs] = approvedVersions ? [null, null] : await Promise.all([
+    getDisplayStatuses(nestId),
+    // From the DB, not a vault walk. The disk truth behind it is
+    // reconciled by the index rebuild and kept current by the stage /
+    // approve / reject paths.
+    nodesWithSuggestions(nestId)
+  ]);
   const authorship = publicReader ? null : await resolveAuthorship(
     nestId,
     accessible.map((d) => ({
@@ -2249,22 +2066,125 @@ async function listNodesForCaller(nestId, userId, filters = {}) {
         return r;
       }
       let pending = null;
-      try {
-        pending = await getPendingChange(nestId, doc.id);
-      } catch {
-        pending = null;
+      if (driftedDocs?.has(doc.id)) {
+        try {
+          pending = await getPendingChange(nestId, doc.id);
+        } catch {
+          pending = null;
+        }
       }
       if (pending) {
         r.pendingChange = pending;
         r.status = "external_edit_pending";
       } else {
-        r.status = await getDisplayStatus(nestId, r.id);
+        r.status = displayStatuses?.get(r.id) ?? "draft";
       }
       return r;
     })
   );
   return enriched;
 }
+function withSubtreeTotals(direct) {
+  return direct.map(({ path, count }) => ({
+    path,
+    count,
+    total: direct.reduce(
+      (sum, f) => f.path === path || f.path.startsWith(`${path}/`) ? sum + f.count : sum,
+      0
+    )
+  })).sort((a, b) => a.path.localeCompare(b.path));
+}
+async function listNestFolders(nestId, opts = {}) {
+  if (opts.folder !== void 0) assertSafeFolder(opts.folder);
+  await ensureNodeIndex(nestId);
+  const counts = /* @__PURE__ */ new Map();
+  for (const { path, count } of await indexedFolderCounts(nestId)) {
+    counts.set(path, count);
+    let parent = path;
+    while (parent.includes("/")) {
+      parent = parent.slice(0, parent.lastIndexOf("/"));
+      if (!counts.has(parent)) counts.set(parent, 0);
+    }
+  }
+  const direct = [...counts].map(([path, count]) => ({ path, count }));
+  const scope = opts.folder ?? "";
+  const inScope = direct.filter((f) => {
+    if (scope && !f.path.startsWith(`${scope}/`)) return false;
+    if (opts.recursive === false) {
+      const rel = scope ? f.path.slice(scope.length + 1) : f.path;
+      return !rel.includes("/");
+    }
+    return true;
+  });
+  return withSubtreeTotals(inScope);
+}
+var RECENT_LIMIT = 3;
+async function nestCensus(nestId, userId) {
+  const userEmail = await resolveCallerEmail(userId);
+  await ensureNodeIndex(nestId);
+  const documents = await readIndexedNodes(nestId);
+  const visible = await filterAccessible(nestId, userId, userEmail, documents);
+  const tags = {};
+  const types = {};
+  const direct = /* @__PURE__ */ new Map();
+  const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1e3;
+  let editedLast7d = 0;
+  for (const d of visible) {
+    const fm = d.frontmatter;
+    types[fm.type || "document"] = (types[fm.type || "document"] || 0) + 1;
+    for (const t of fm.tags || []) tags[String(t)] = (tags[String(t)] || 0) + 1;
+    const folder = folderOfId(d.id);
+    if (folder) direct.set(folder, (direct.get(folder) || 0) + 1);
+    const edited = Date.parse(String(fm.updated_at || ""));
+    if (!Number.isNaN(edited) && edited >= cutoff) editedLast7d++;
+  }
+  const paths = /* @__PURE__ */ new Set();
+  for (const folder of direct.keys()) {
+    const segs = folder.split("/");
+    for (let i = 1; i <= segs.length; i++) paths.add(segs.slice(0, i).join("/"));
+  }
+  const folders = withSubtreeTotals(
+    [...paths].map((path) => ({ path, count: direct.get(path) ?? 0 }))
+  );
+  const statusMap = await getDisplayStatuses(nestId);
+  const statuses = {};
+  for (const d of visible) {
+    const st = statusMap.get(d.id) ?? "draft";
+    statuses[st] = (statuses[st] || 0) + 1;
+  }
+  const authorship = await resolveAuthorship(
+    nestId,
+    visible.map((d) => ({
+      id: d.id,
+      frontmatterAuthor: d.frontmatter.author ?? null
+    }))
+  );
+  const authors = [
+    ...new Set(
+      [...authorship.values()].map((a) => a.author).filter((a) => !!a)
+    )
+  ].sort((a, b) => a.localeCompare(b));
+  const recent = visible.filter((d) => d.frontmatter.updated_at).sort(
+    (a, b) => String(b.frontmatter.updated_at).localeCompare(
+      String(a.frontmatter.updated_at)
+    )
+  ).slice(0, RECENT_LIMIT).map((d) => ({
+    id: d.id,
+    title: String(d.frontmatter.title ?? ""),
+    type: d.frontmatter.type || "document",
+    updated_at: d.frontmatter.updated_at
+  }));
+  return {
+    total: visible.length,
+    folders,
+    tags,
+    types,
+    statuses,
+    authors,
+    editedLast7d,
+    recent
+  };
+}
 async function listNodesForCallerByEmail(nestId, userEmail, filters = {}) {
   return listNodesForCaller(nestId, await userIdFromEmail(userEmail), filters);
 }
@@ -2290,14 +2210,27 @@ async function autoPublishReason(nestId, userEmail, doc) {
   return await actorAutoPublishes(nestId, userEmail) ? "owner/admin self-approve" : null;
 }
 async function createNode(nestId, input, userEmail) {
+  const generatedId = !input.id && !slugify(input.title);
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await createNodeOnce(nestId, input, userEmail);
+    } catch (err) {
+      if (!generatedId || attempt >= 3 || !(err instanceof ConflictError)) {
+        throw err;
+      }
+    }
+  }
+}
+async function createNodeOnce(nestId, input, userEmail) {
   const { storage, versions: versionManager } = await engineCache.get(nestId);
   assertTitleLength(input.title);
-  if (!input.id) assertTitleSluggable(input.title);
+  assertTitleReadable(input.title);
   const slug = slugify(input.title).slice(0, 100).replace(/-+$/, "");
   let id = input.id;
   if (!id) {
     const folderSegments = folderToSegments(input.folder ?? "");
-    id = folderSegments.length > 0 ? `nodes/${folderSegments.join("/")}/${slug}` : `nodes/${slug}`;
+    const prefix = folderSegments.length > 0 ? `nodes/${folderSegments.join("/")}/` : "nodes/";
+    id = `${prefix}${slug || await generatedSlug(storage, prefix)}`;
   }
   const tags = (input.tags || []).map(normalizeTag2);
   const requestedType = input.type || "document";
@@ -2307,6 +2240,11 @@ async function createNode(nestId, input, userEmail) {
   if (requestedType === "table" && !config.TYPE_TABLE_ENABLED) {
     throw new ValidationError("Table nodes are disabled on this server");
   }
+  if (!ACCEPTED_NODE_TYPES.has(requestedType)) {
+    throw new ValidationError(
+      `unknown node type "${requestedType}"; allowed: ${[...ACCEPTED_NODE_TYPES].sort().join(", ")}`
+    );
+  }
   if (input.schedule !== void 0 && !isRunnableType(input.type)) {
     throw new ValidationError(
       `schedule is only valid for runnable node types (${RUNNABLE_NODE_TYPES.join(
@@ -2558,7 +2496,7 @@ async function updateNode(nestId, nodeId, patch, userEmail) {
       if (patch.title) {
         if (patch.title !== node.frontmatter.title) {
           assertTitleLength(patch.title);
-          assertTitleSluggable(patch.title);
+          assertTitleReadable(patch.title);
         }
         node = {
           ...node,
@@ -2706,6 +2644,8 @@ var NODE_KEYED_TABLES = [
   ["annotation_threads", "node_id"],
   ["comments", "node_id"],
   ["node_tag_index", "node_id"],
+  ["node_index", "node_id"],
+  ["node_suggestions", "node_id"],
   ["watchers", "node_id"],
   ["schedules", "agent_node"],
   // A live capability token bound to one agent node — deleting the agent must
@@ -2784,8 +2724,8 @@ async function moveNode(nestId, nodeId, folder, userEmail) {
     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);
+      const oldChain = join(nestPath, dirname(nodeId), ".versions", leaf);
+      const newChain = join(nestPath, dirname(newId), ".versions", leaf);
       if (oldChain !== newChain) {
         await mkdir(dirname(newChain), { recursive: true });
         await rename(oldChain, newChain);
@@ -2818,6 +2758,11 @@ async function moveNode(nestId, nodeId, folder, userEmail) {
       await storage.deleteDocument(oldDerived);
     } catch {
     }
+    try {
+      await storage.regenerateIndex();
+    } catch (err) {
+      console.error("[move] regenerateIndex failed", nestId, nodeId, newId, err);
+    }
     await trackEvent("node.move", { nestId, nodeId, newId });
     return { node: moved, previousId: nodeId };
   });
@@ -2888,7 +2833,7 @@ async function deleteFolder(nestId, folder, userEmail) {
 
 // src/nests/unsynced-service.ts
 import { readdirSync, readFileSync, statSync } from "fs";
-import { join as join3, relative, resolve } from "path";
+import { join as join2, relative, resolve } from "path";
 import { rm } from "fs/promises";
 var RESERVED = /* @__PURE__ */ new Set(["nests"]);
 function isNestStorageRoot(absPath) {
@@ -2905,7 +2850,7 @@ function scanMarkdown(dir) {
   }
   for (const e of entries) {
     if (e.name.startsWith(".") || e.name === "node_modules") continue;
-    const full = join3(dir, e.name);
+    const full = join2(dir, e.name);
     if (e.isDirectory()) {
       const sub = scanMarkdown(full);
       count += sub.count;
@@ -2955,7 +2900,7 @@ function collectLeafFolders(rel, abs) {
     if (!e.isDirectory()) continue;
     if (e.name.startsWith(".") || e.name === "node_modules") continue;
     out.push(
-      ...collectLeafFolders(`${rel}/${e.name}`, join3(abs, e.name))
+      ...collectLeafFolders(`${rel}/${e.name}`, join2(abs, e.name))
     );
   }
   return out;
@@ -2973,7 +2918,7 @@ function listUnsyncedFolders() {
     if (!e.isDirectory()) continue;
     if (e.name.startsWith(".")) continue;
     if (RESERVED.has(e.name)) continue;
-    const abs = join3(root, e.name);
+    const abs = join2(root, e.name);
     if (isNestStorageRoot(abs)) continue;
     out.push(...collectLeafFolders(e.name, abs));
   }
@@ -3010,7 +2955,7 @@ function collectMarkdownFiles(dir, root) {
   }
   for (const e of entries) {
     if (e.name.startsWith(".") || e.name === "node_modules") continue;
-    const full = join3(dir, e.name);
+    const full = join2(dir, e.name);
     if (e.isDirectory()) {
       out.push(...collectMarkdownFiles(full, root));
     } else if (e.isFile() && e.name.toLowerCase().endsWith(".md")) {
@@ -3028,7 +2973,7 @@ async function syncUnsyncedFolder(userId, folderName, callerEmail) {
     `[unsynced] sync requested folder="${folderName}" user="${callerEmail}"`
   );
   assertSafeFolderName(folderName);
-  const src = join3(config.DATA_ROOT, folderName);
+  const src = join2(config.DATA_ROOT, folderName);
   if (isNestStorageRoot(src)) {
     throw new ValidationError("Folder is not eligible for sync");
   }
@@ -3084,7 +3029,7 @@ async function syncUnsyncedFolder(userId, folderName, callerEmail) {
 async function deleteUnsyncedFolder(folderName) {
   console.log(`[unsynced] delete requested folder="${folderName}"`);
   assertSafeFolderName(folderName);
-  const src = join3(config.DATA_ROOT, folderName);
+  const src = join2(config.DATA_ROOT, folderName);
   if (isNestStorageRoot(src)) {
     throw new ValidationError("Folder is not eligible for delete");
   }
@@ -3180,9 +3125,11 @@ nestRoutes.get("/", async (c) => {
   }
   const out = await Promise.all(deduped.map(annotate));
   const docRows = await db.all(
-    "SELECT nest_id, COUNT(DISTINCT node_id) AS c FROM node_versions GROUP BY nest_id"
+    `SELECT nest_id, COUNT(DISTINCT node_id) AS c, MAX(created_at) AS last_activity
+       FROM node_versions GROUP BY nest_id`
   );
   const docByNest = new Map(docRows.map((r) => [r.nest_id, Number(r.c)]));
+  const activityByNest = new Map(docRows.map((r) => [r.nest_id, r.last_activity]));
   const collabRows = await db.all(
     "SELECT nest_id, COUNT(*) AS c FROM nest_collaborators GROUP BY nest_id"
   );
@@ -3236,6 +3183,7 @@ nestRoutes.get("/", async (c) => {
       collaborator_emails: []
     } : {
       ...n,
+      last_activity: activityByNest.get(n.id) ?? null,
       document_count: docByNest.get(n.id) ?? 0,
       collaborator_count: collabByNest.get(n.id) ?? 0,
       steward_count: stewardByNest.get(n.id) ?? 0,
@@ -3499,7 +3447,7 @@ async function addCollaborator(params) {
     if (existing) {
       userId = existing.id;
     } else {
-      const { hashPassword: hashPassword2 } = await import("./keys-73STFJJB.js");
+      const { hashPassword: hashPassword2 } = await import("./keys-CTOGAG3W.js");
       userId = uuid3();
       await db.run(
         "INSERT INTO users (id, email, name, password_hash, is_invited) VALUES (?, ?, ?, ?, 1)",
@@ -3691,7 +3639,7 @@ async function resolveGrantee(email) {
   const e = normalizeEmail(email);
   const existing = await db.get("SELECT id FROM users WHERE LOWER(email) = ?", [e]);
   if (existing) return existing.id;
-  const { hashPassword: hashPassword2 } = await import("./keys-73STFJJB.js");
+  const { hashPassword: hashPassword2 } = await import("./keys-CTOGAG3W.js");
   const id = uuid4();
   await db.run(
     "INSERT INTO users (id, email, name, password_hash, is_invited) VALUES (?, ?, ?, ?, 1)",
@@ -3699,6 +3647,41 @@ async function resolveGrantee(email) {
   );
   return id;
 }
+async function assertGrantAddsAccess(params) {
+  const { nestId, email, userId, targetType, target, role } = params;
+  const roles = [];
+  if (userId) {
+    const access = await resolveNestAccess(nestId, userId);
+    if (access.ownerId === userId) roles.push("owner");
+    const collab = collabPermToRole(access.collaboratorPermission);
+    if (collab) roles.push(collab);
+    for (const teamRole of await resolveTeamRolesForUser(nestId, userId)) {
+      roles.push(teamRole);
+    }
+  }
+  if (targetType === "document") {
+    const stewards = await resolveStewardsForNode(nestId, target);
+    for (const s of stewards) {
+      if (s.steward.userEmail.toLowerCase() === email.toLowerCase()) {
+        roles.push(s.steward.role);
+      }
+    }
+  }
+  const covered = role === "write" ? canEditWith(roles) : roles.length > 0;
+  if (covered) {
+    const held = primaryRole(roles) ?? "existing";
+    throw new ValidationError(
+      `${email} already has ${held} access here, so this ${targetType} is already ${role === "write" ? "editable by" : "visible to"} them.`
+    );
+  }
+  if (!userId) return;
+  const existing = await resolveNodeGrant(nestId, userId, target);
+  if (existing && (role === "read" || existing === "write")) {
+    throw new ValidationError(
+      `${email} has already been shared this ${targetType} (${existing === "write" ? "can edit" : "can view"}).`
+    );
+  }
+}
 grantRoutes.post("/", async (c) => {
   const nestId = c.req.param("nestId");
   await requireManage(c, nestId);
@@ -3714,7 +3697,19 @@ grantRoutes.post("/", async (c) => {
   if (!["read", "write"].includes(role)) {
     throw new ValidationError("role must be read | write");
   }
-  const userId = await resolveGrantee(body.email);
+  const email = normalizeEmail(body.email);
+  const known = await getDb().get("SELECT id FROM users WHERE LOWER(email) = ?", [
+    email
+  ]);
+  await assertGrantAddsAccess({
+    nestId,
+    email,
+    userId: known?.id ?? null,
+    targetType,
+    target,
+    role
+  });
+  const userId = known?.id ?? await resolveGrantee(body.email);
   const grant = await createGrant({
     nestId,
     targetType,
@@ -4122,7 +4117,7 @@ function toSearchHit(node, query) {
 import { Hono as Hono8 } from "hono";
 
 // src/nodes/markdown-export.ts
-import { parseDocument as parseDocument3 } from "@promptowl/contextnest-engine";
+import { parseDocument as parseDocument2 } from "@promptowl/contextnest-engine";
 function nodeToMarkdown(node) {
   const tags = node.tags ?? [];
   return [
@@ -4158,7 +4153,7 @@ function rawContentType(nodeType) {
 function frontmatterBlockOf(raw) {
   if (!raw || !raw.startsWith("---")) return "";
   try {
-    const body = parseDocument3("frontmatter-split.md", raw, "frontmatter-split").body ?? "";
+    const body = parseDocument2("frontmatter-split.md", raw, "frontmatter-split").body ?? "";
     if (raw.endsWith(body)) return raw.slice(0, raw.length - body.length);
   } catch {
   }
@@ -4204,7 +4199,14 @@ nodeRoutes.get("/", async (c) => {
     // 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 } : {}
+    ...limit !== void 0 && Number.isFinite(limit) && limit > 0 ? { limit } : {},
+    // Present (even as "") = one folder level only, for the lazily-expanded
+    // document tree. Absent = the whole nest, as every existing caller expects.
+    ...q.folder !== void 0 ? { folder: q.folder } : {},
+    // Bodies are off by default — the list is served from the DB index, which
+    // holds metadata only. Opt back in and the listing crawls the vault for
+    // them; kept for any client that was reading `content` off this route.
+    ...q.content === "1" || q.content === "true" ? { withContent: true } : {}
   });
   return c.json({ count: nodes.length, nodes });
 });
@@ -4246,7 +4248,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-OHTTZFND.js");
+  const { resolveStewardsWithFallback: resolveStewardsWithFallback2 } = await import("./stewardship-service-JAFSU5GN.js");
   const { stewards, fallbackToOwner, ownerEmail } = await resolveStewardsWithFallback2(
     nestId,
     nodeId
@@ -4267,7 +4269,7 @@ nodeRoutes.get("/:nodeId{.+}/stewards", async (c) => {
 nodeRoutes.get("/:nodeId{.+}/reviews", async (c) => {
   const nestId = c.req.param("nestId");
   const nodeId = c.req.param("nodeId");
-  const { getReviewHistory: getReviewHistory2 } = await import("./review-service-3CCKDO5N.js");
+  const { getReviewHistory: getReviewHistory2 } = await import("./review-service-LK4M2C43.js");
   const history = await getReviewHistory2(nestId, nodeId);
   return c.json({ reviews: history });
 });
@@ -4906,7 +4908,6 @@ annotationRoutes.get("/:nodeId{.+}/hosted", async (c) => {
 
 // src/nodes/query-routes.ts
 import { Hono as Hono10 } from "hono";
-import { serializeDocument as serializeDocument3 } from "@promptowl/contextnest-engine";
 
 // src/tables/service.ts
 function splitCsvLine(line) {
@@ -5327,7 +5328,7 @@ async function resolveExportBody(nestId, nodeId, workingBody) {
 
 // src/nests/bundle-service.ts
 import { readdirSync as readdirSync2, readFileSync as readFileSync2, statSync as statSync2 } from "fs";
-import { join as join4, sep } from "path";
+import { join as join3, sep } from "path";
 import JSZip from "jszip";
 import { serializeDocument as serializeDocument2 } from "@promptowl/contextnest-engine";
 function walkFiles(root) {
@@ -5340,7 +5341,7 @@ function walkFiles(root) {
   }
   for (const rel of entries) {
     try {
-      if (statSync2(join4(root, rel)).isFile()) out.push(rel.split(sep).join("/"));
+      if (statSync2(join3(root, rel)).isFile()) out.push(rel.split(sep).join("/"));
     } catch {
     }
   }
@@ -5381,7 +5382,7 @@ async function exportNestBundle(nestId, includeDrafts) {
     const segs = rel.split("/");
     const keep = segs.includes(".versions") || rel === ".context/config.yaml" || rel === "CONTEXT.md";
     if (!keep) continue;
-    zip.file(rel, readFileSync2(join4(nestPath, rel)));
+    zip.file(rel, readFileSync2(join3(nestPath, rel)));
   }
   trackEvent("nest.export.bundle", { nestId, documents: count, includeDrafts });
   return zip.generateAsync({ type: "arraybuffer" });
@@ -5552,7 +5553,9 @@ queryRoutes.get("/changes", async (c) => {
   const includeContent = ["1", "true"].includes(
     c.req.query("include_content") || ""
   );
-  const all = await listNodesForCaller(nestId, userId);
+  const all = await listNodesForCaller(nestId, userId, {
+    ...includeContent ? { withContent: true } : {}
+  });
   const db = getDb();
   const publicReader = await isPublicReader(nestId, userId);
   const approvedRows = await db.all(
@@ -5619,7 +5622,10 @@ queryRoutes.get("/runnables", async (c) => {
   const nestId = c.req.param("nestId");
   const userId = c.get("userId");
   const all = await listNodesForCaller(nestId, userId, {
-    type: RUNNABLE_NODE_TYPES
+    type: RUNNABLE_NODE_TYPES,
+    // The prompt/skill body IS the payload here — an orchestrator pulls it to
+    // run the thing, so this surface pays for the file reads.
+    withContent: true
   });
   const runnables = all.map((n) => ({
     id: n.id,
@@ -5661,11 +5667,15 @@ queryRoutes.get("/graph", async (c) => {
 function approxTokens(text) {
   return Math.ceil(text.length / 4);
 }
-function formatContextBlock(node) {
+function formatContextBlock(node, url) {
   const tags = (node.frontmatter.tags || []).join(" ");
-  const header = tags ? `# ${node.frontmatter.title}
+  const meta = [
+    tags ? `_tags: ${tags}_` : null,
+    url ? `_source: ${url}_` : null
+  ].filter(Boolean);
+  const header = meta.length ? `# ${node.frontmatter.title}
 
-_tags: ${tags}_
+${meta.join("\n")}
 
 ` : `# ${node.frontmatter.title}
 
@@ -5678,6 +5688,7 @@ queryRoutes.post("/context", async (c) => {
     throw new ValidationError("prompt or selector is required");
   }
   const nestId = c.req.param("nestId");
+  const baseUrl = requestBaseUrl(c.req.url);
   const { query: queryEngine, storage } = await engineCache.get(nestId);
   const maxTokens = Math.max(50, body.max_tokens ?? 4e3);
   const hops = body.hops ?? 2;
@@ -5786,20 +5797,21 @@ queryRoutes.post("/context", async (c) => {
   const readable = await Promise.all(
     accessible.map(async (doc) => ({
       ...doc,
-      body: await resolveReadableBody(nestId, doc.id, userId, doc.body || "")
+      body: await resolveReadableBody(nestId, doc.id, userId, doc.body || ""),
+      url: resolveNodeUrl(doc, { nestId, baseUrl })
     }))
   );
   const included = [];
   let tokenCount = 0;
   for (const doc of readable) {
-    const block = formatContextBlock(doc);
+    const block = formatContextBlock(doc, doc.url);
     const blockTokens = approxTokens(block);
     if (tokenCount + blockTokens > maxTokens && included.length > 0) break;
     included.push(doc);
     tokenCount += blockTokens;
   }
   const truncatedByBudget = accessible.length - included.length;
-  const contextMarkdown = included.map(formatContextBlock).join("\n\n---\n\n");
+  const contextMarkdown = included.map((n) => formatContextBlock(n, n.url)).join("\n\n---\n\n");
   trackEvent("context.resolve", {
     nestId,
     selector_from_prompt: !!compileDetail,
@@ -5812,6 +5824,7 @@ queryRoutes.post("/context", async (c) => {
     nodes: included.map((n) => ({
       id: n.id,
       title: n.frontmatter.title,
+      url: n.url,
       tags: n.frontmatter.tags || [],
       type: n.frontmatter.type || "document"
     })),
@@ -5914,6 +5927,25 @@ queryRoutes.get("/overview", async (c) => {
     }))
   });
 });
+queryRoutes.get("/census", async (c) => {
+  const census = await nestCensus(c.req.param("nestId"), c.get("userId"));
+  return c.json({ census });
+});
+queryRoutes.get("/folders", async (c) => {
+  const q = c.req.query();
+  const folders = await listNestFolders(c.req.param("nestId"), {
+    ...q.folder !== void 0 ? { folder: q.folder } : {},
+    ...q.recursive === "0" || q.recursive === "false" ? { recursive: false } : {}
+  });
+  return c.json({ folders });
+});
+queryRoutes.post("/reindex", async (c) => {
+  if (permissionLevel(c.get("nestPermission")) < permissionLevel("write")) {
+    throw new ForbiddenError("Reindexing a nest requires write access");
+  }
+  const indexed = await rebuildNodeIndex(c.req.param("nestId"));
+  return c.json({ indexed });
+});
 queryRoutes.get("/comment-counts", async (c) => {
   const counts = await countThreadsByNode(c.req.param("nestId"));
   return c.json({ counts });
@@ -6006,48 +6038,51 @@ queryRoutes.post("/publish", async (c) => {
     }
   }
   const nestId = c.req.param("nestId");
-  const { storage } = await engineCache.get(nestId);
+  const userEmail = await resolveCallerEmail(c.get("userId"));
   const created = [];
+  const skipped = [];
+  const failed = [];
   if (body.context_md) {
+    const { storage } = await engineCache.get(nestId);
     await storage.writeContextMd(body.context_md);
+    await storage.regenerateIndex();
   }
   for (const doc of body.documents || []) {
     if (!doc.title || !doc.content) continue;
-    const slug = doc.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-    const id = `nodes/${slug}`;
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const tags = doc.tags?.map((t) => t.startsWith("#") ? t : `#${t}`) || [];
-    const node = {
-      id,
-      filePath: "",
-      frontmatter: {
+    try {
+      const result = await createNode(
+        nestId,
+        {
+          title: doc.title,
+          content: doc.content,
+          type: doc.type,
+          tags: doc.tags,
+          scope: doc.scope
+        },
+        userEmail
+      );
+      created.push(result.node.id);
+    } catch (err) {
+      if (err instanceof ConflictError) {
+        skipped.push(doc.title);
+        continue;
+      }
+      if (isVaultLockTimeout(err) || err instanceof VaultBusyError) throw err;
+      if (!(err instanceof AppError)) console.error("bulk publish row failed", err);
+      failed.push({
         title: doc.title,
-        type: doc.type || "document",
-        tags,
-        status: "draft",
-        version: 1,
-        created_at: now,
-        updated_at: now,
-        metadata: {
-          owners: ["*"],
-          scope: doc.scope || "team"
-        }
-      },
-      body: doc.content,
-      rawContent: ""
-    };
-    const serialized = serializeDocument3(node);
-    await storage.writeDocument(id, serialized);
-    await syncNodeTags(nestId, id, tags);
-    created.push(id);
+        error: err instanceof AppError ? err.message : "Could not create this document"
+      });
+    }
   }
-  if (created.length > 0 || body.context_md) await storage.regenerateIndex();
   trackEvent("nest.publish", { nestId, count: created.length });
   return c.json(
     {
       published: created.length,
       context_md_updated: !!body.context_md,
-      node_ids: created
+      node_ids: created,
+      skipped,
+      failed
     },
     201
   );
@@ -6058,30 +6093,6 @@ 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;
@@ -6385,6 +6396,30 @@ async function appendRunStep(runId, input) {
   return { seq };
 }
 var RUN_STATUSES = ["running", "succeeded", "failed", "cancelled"];
+async function cancelDescendants(runId) {
+  const db = getDb();
+  const at = (/* @__PURE__ */ new Date()).toISOString();
+  const trace = JSON.stringify({ error: "Parent run cancelled" });
+  let frontier = [runId];
+  let cancelled = 0;
+  for (let depth = 0; frontier.length && depth < 64; depth++) {
+    const ph = frontier.map(() => "?").join(",");
+    const kids = await db.all(
+      `SELECT id FROM runs WHERE parent_run_id IN (${ph}) AND status = 'running'`,
+      frontier
+    );
+    if (!kids.length) break;
+    frontier = kids.map((k) => k.id);
+    const kph = frontier.map(() => "?").join(",");
+    await db.run(
+      `UPDATE runs SET status = 'cancelled', trace = COALESCE(trace, ?), finished_at = ?
+        WHERE id IN (${kph}) AND status = 'running'`,
+      [trace, at, ...frontier]
+    );
+    cancelled += frontier.length;
+  }
+  return cancelled;
+}
 async function closeRun(runId, input) {
   const status = input.status;
   if (typeof status !== "string" || !RUN_STATUSES.includes(status)) {
@@ -6406,6 +6441,7 @@ async function closeRun(runId, input) {
     if (!run) throw new NotFoundError("Run not found");
     throw new ConflictError("Run already terminal \u2014 status can't be changed");
   }
+  if (status === "cancelled") await cancelDescendants(runId);
   return { status };
 }
 async function getRunTrace(run, opts) {
@@ -7656,6 +7692,13 @@ async function handleToolCall(toolName, args, ctx) {
   try {
     return await runTool(toolName, args, ctx);
   } catch (err) {
+    if (isVaultLockTimeout(err) || err instanceof VaultBusyError) {
+      status = 503;
+      return toolError(
+        "The vault is busy with another write. Retry in a few seconds.",
+        "VAULT_BUSY"
+      );
+    }
     status = 500;
     throw err;
   } finally {
@@ -7709,7 +7752,9 @@ ${context_md}`;
         {},
         await opContext(nestId, userEmail)
       );
-      const visible = await listNodesForCallerByEmail(nestId, userEmail, {});
+      const visible = await listNodesForCallerByEmail(nestId, userEmail, {
+        withContent: true
+      });
       const types = {};
       const tags = {};
       for (const n of visible) {
@@ -8544,14 +8589,14 @@ ${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-4NXPBYWD.js");
-        const db = (await import("./client-OBS5HOTA.js")).getDb();
+        const { createGrant: createGrant2 } = await import("./grants-service-CADI6LIB.js");
+        const db = (await import("./client-SW5I6ZBK.js")).getDb();
         const { normalizeEmail: normalizeEmail2 } = await import("./email-R7DFS6E5.js");
         const e = normalizeEmail2(String(args.email || ""));
         if (!e) return "email is required.";
         let row = await db.get("SELECT id FROM users WHERE LOWER(email) = ?", [e]);
         if (!row) {
-          const { hashPassword: hashPassword2 } = await import("./keys-73STFJJB.js");
+          const { hashPassword: hashPassword2 } = await import("./keys-CTOGAG3W.js");
           const { v4: uuid16 } = await import("uuid");
           const id = uuid16();
           await db.run(
@@ -9014,8 +9059,9 @@ runDetailRoutes.patch("/:id", requireWorkflowPlane, async (c) => {
     throw new ValidationError("status must be running | succeeded | failed | cancelled");
   }
   const terminal = status !== "running";
-  await getDb().run(
-    `UPDATE runs SET status = ?, trace = COALESCE(?, trace), finished_at = ? WHERE id = ?`,
+  const res = await getDb().run(
+    `UPDATE runs SET status = ?, trace = COALESCE(?, trace), finished_at = ?
+      WHERE id = ? AND status = 'running'`,
     [
       status,
       body.trace === void 0 ? null : JSON.stringify(body.trace),
@@ -9023,6 +9069,13 @@ runDetailRoutes.patch("/:id", requireWorkflowPlane, async (c) => {
       run.id
     ]
   );
+  if (!res.changes) {
+    const now = await getDb().get("SELECT status FROM runs WHERE id = ?", [
+      run.id
+    ]);
+    throw new ConflictError(`Run already terminal (${now?.status ?? "closed"})`);
+  }
+  if (status === "cancelled") await cancelDescendants(run.id);
   if (status === "failed") {
     const err = body.trace && typeof body.trace === "object" ? String(body.trace.error ?? "").slice(0, 200) : "";
     void dispatchEvent({
@@ -9631,8 +9684,8 @@ definitionRoutes.delete("/:id", async (c) => {
 // src/nests/asset-routes.ts
 import { Hono as Hono18 } from "hono";
 import { v4 as uuid13 } from "uuid";
-import { mkdir as mkdir2, readFile as readFile2, writeFile } from "fs/promises";
-import { join as join5 } from "path";
+import { mkdir as mkdir2, readFile, writeFile } from "fs/promises";
+import { join as join4 } from "path";
 var assetRoutes = new Hono18();
 var CONTENT_TYPES = {
   png: "image/png",
@@ -9680,9 +9733,9 @@ assetRoutes.post("/", async (c) => {
     );
   }
   const name = `${uuid13()}.${ext === "jpeg" ? "jpg" : ext}`;
-  const dir = join5(resolveNestPath(nestId), "assets");
+  const dir = join4(resolveNestPath(nestId), "assets");
   await mkdir2(dir, { recursive: true });
-  await writeFile(join5(dir, name), Buffer.from(await file.arrayBuffer()));
+  await writeFile(join4(dir, name), Buffer.from(await file.arrayBuffer()));
   const url = `/nests/${nestId}/assets/${name}`;
   return c.json(
     {
@@ -9704,7 +9757,7 @@ assetRoutes.get("/:file", async (c) => {
   }
   let bytes;
   try {
-    bytes = await readFile2(join5(resolveNestPath(nestId), "assets", name));
+    bytes = await readFile(join4(resolveNestPath(nestId), "assets", name));
   } catch {
     throw new NotFoundError("Asset not found");
   }
@@ -10514,7 +10567,7 @@ function rowToComment(row) {
 
 // src/governance/stewards-parser.ts
 import { readFileSync as readFileSync3, existsSync } from "fs";
-import { join as join6 } from "path";
+import { join as join5 } from "path";
 function parseStewardsYaml(content) {
   const result = { version: 1 };
   const lines = content.split("\n");
@@ -10580,9 +10633,9 @@ function parseEntry(str) {
 function loadStewardsConfig(nestId) {
   const nestPath = resolveNestPath(nestId);
   const candidates = [
-    join6(nestPath, "stewards.yaml"),
-    join6(nestPath, "stewards.yml"),
-    join6(nestPath, ".context", "stewards.yaml")
+    join5(nestPath, "stewards.yaml"),
+    join5(nestPath, "stewards.yml"),
+    join5(nestPath, ".context", "stewards.yaml")
   ];
   for (const candidatePath of candidates) {
     if (existsSync(candidatePath)) {
@@ -10943,7 +10996,7 @@ governanceNodeRoutes.get("/:nodeId{.+}/versions", async (c) => {
   const approved = await getApprovedVersion(nestId, nodeId);
   const { versions: versionManager } = await engineCache.get(nestId);
   const resolutions = await getDb().all(
-    `SELECT version, status, resolved_by
+    `SELECT version, status, resolved_by, resolution_note
        FROM review_requests
       WHERE nest_id = ? AND node_id = ?
         AND status IN ('approved', 'rejected')
@@ -10954,13 +11007,21 @@ governanceNodeRoutes.get("/:nodeId{.+}/versions", async (c) => {
   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 });
+      byVersion.set(r.version, {
+        status: r.status,
+        resolvedBy: r.resolved_by,
+        resolutionNote: r.resolution_note?.trim() || void 0
+      });
     }
   }
   const enriched = await Promise.all(
     allVersions.map(async (v) => {
       const r = byVersion.get(v.version);
-      const resolution = r ? { resolvedBy: r.resolvedBy, resolutionStatus: r.status } : {};
+      const resolution = r ? {
+        resolvedBy: r.resolvedBy,
+        resolutionStatus: r.status,
+        resolutionNote: r.resolutionNote
+      } : {};
       try {
         const diff = await versionManager.getDiff(nodeId, v.version);
         return { ...v, ...resolution, diff: diff ?? void 0 };
@@ -11338,19 +11399,19 @@ async function ensureAnonymousUser() {
 // src/app.ts
 import { serveStatic } from "@hono/node-server/serve-static";
 import { fileURLToPath } from "url";
-import { dirname as dirname2, join as join7, relative as relative2 } from "path";
+import { dirname as dirname2, join as join6, relative as relative2 } from "path";
 import { existsSync as existsSync2, readFileSync as readFileSync4 } from "fs";
 var HERE = dirname2(fileURLToPath(import.meta.url));
 var SERVICE_VERSION = (() => {
   try {
-    return JSON.parse(readFileSync4(join7(HERE, "..", "package.json"), "utf8")).version;
+    return JSON.parse(readFileSync4(join6(HERE, "..", "package.json"), "utf8")).version;
   } catch {
     return "unknown";
   }
 })();
 var UI_DIR_CANDIDATES = [
-  join7(HERE, "web3"),
-  join7(process.cwd(), "dist", "web3")
+  join6(HERE, "web3"),
+  join6(process.cwd(), "dist", "web3")
 ];
 var UI_DIR_ABS = UI_DIR_CANDIDATES.find((p) => existsSync2(p)) || UI_DIR_CANDIDATES[0];
 var UI_DIR_REL = relative2(process.cwd(), UI_DIR_ABS) || ".";
@@ -12508,6 +12569,12 @@ function createApp() {
   );
   app.notFound((c) => c.json({ error: "Not found" }, 404));
   app.onError((err, c) => {
+    if (isVaultLockTimeout(err) || err instanceof VaultBusyError) {
+      const busy = err instanceof VaultBusyError ? err : new VaultBusyError();
+      return c.json({ error: busy.message }, 503, {
+        "Retry-After": String(busy.retryAfterSeconds)
+      });
+    }
     if (err instanceof AppError) {
       return c.json({ error: err.message }, err.statusCode);
     }