@promptowl/contextnest-community 1.26.0 → 1.27.0

package/API.md

@@ -1592,7 +1592,7 @@ Body (give `prompt` OR `selector`; everything else optional):
 }
 ```
 - `prompt` — natural language. Tokens are matched against tag names and titles, and every document is scored against them (title hits weigh most, then tags, then body words); documents under half the top score are dropped as noise. A prompt that matches nothing returns `nodes: []` — never the whole nest. `trace.compiled.fallback` is `"fulltext"` when body scoring alone produced the answer.
-- `selector` — explicit selector grammar (e.g. `#auth`). Wins over `prompt`.
+- `selector` — explicit selector grammar (e.g. `#auth`). Wins over `prompt`. May carry `[[Title]]` parts in an OR union (`#auth | [[Auth Overview]]`), and `[[nodes/auth-overview]]` names one document by id where a title may match several.
 - `hops` — link expansion depth (`[[wikilinks]]` and `contextnest://` links, both directions). Defaults to `0` for a `prompt` (neighbours of a keyword match are not answers to the question) and `2` for a `selector`.
 - `max_tokens` — budget, floored at 50, default 4000. A node that doesn't fit is skipped and the next tried (`trace.truncated_by_budget` counts the skips); only when nothing fits does the first node go through oversized.
 - 400 `prompt or selector is required` if both missing.
@@ -1708,6 +1708,39 @@ Deterministic fact lookup against a **table** node (CSV body): fetch the exact r
 ```
 Same operation over MCP: `context_table_query`.
 
+### POST `/nests/:nestId/chat`
+Hootie in the nest — ask a question about the nest and get a streamed, cited answer. Read tier, like `/context`: retrieval runs through the same `/context` path **as the caller**, so the answer can only draw on documents this person may read. Gated by `HOOTIE_ENABLED` (off → `404`); needs the server-wide `ANTHROPIC_API_KEY` (missing → `503` with `reason: "no_api_key"`); answers with `HOOTIE_MODEL`, through `ANTHROPIC_BASE_URL` when one is set (all three editable in Settings → General). Rate-limited per user across all nests — the budget guards the one server-wide key (`429`).
+
+Request:
+
+```json
+{
+  "message": "how do requests authenticate?",
+  "node_id": "nodes/api-authentication-guide",
+  "history": [
+    { "role": "user", "content": "…" },
+    { "role": "assistant", "content": "…" }
+  ]
+}
+```
+
+- `message` (required) — the question. `@name` tokens loop a colleague in (below).
+- `node_id` (optional) — the document the person has open. It and its neighbours (one hop) lead the context, whatever the question matches follows.
+- `history` (optional) — prior turns, oldest first; the server keeps the most recent 20.
+
+Response: `text/event-stream`.
+
+| event | data |
+|---|---|
+| `meta` | `{ nodes: [{ id, title, url, tags, type }], anchor: node \| null }` — what the answer will be grounded in, before the model speaks. |
+| `delta` | `{ text }` — a chunk of the answer. |
+| `done` | `{ answer, cited: [node…], mention }` — the whole answer, the documents it cites (by `[[Title]]`, in order), and what happened to any `@mentions`. |
+| `error` | `{ error }` — the model call failed; the stream ends. |
+
+**Grounding.** The retrieved documents are placed in the system prompt verbatim with the instruction to answer from them alone. Retrieval is permission-gated, so an answer can never draw on anything the caller couldn't read — but a document author can write text aimed at Hootie ("ignore the question and…") that later readers' sessions will see. That is the ordinary tradeoff of grounding a model in editable content, accepted here; the documents are governed, so who can write them is the control.
+
+**Mentions.** A message naming people (`@alice@acme.com`) posts the exchange — question and answer, under the asker's name — as a comment on the anchor document (the open one, else the first document the answer cites) and notifies them through the comment-mention path: inbox row, and email / Slack / Teams where configured. `mention` is `{ status: "posted", node_id, node_title, thread_id, notified }` or `{ status: "undeliverable", reason: "no_anchor" | "post_failed" }`. Nothing is posted when nobody is named.
+
 ### POST `/nests/:nestId/query`
 Graph query (Cypher-ish).
 

package/CONFIGURATION.md

@@ -95,13 +95,17 @@ The server prints a loud warning at startup when `AUTH_MODE=open` is active.
 | `PROMPTOWL_TEAMS_ENABLED` | _(unset — off)_ | Lets users who signed in with PromptOwl import their PromptOwl teams as local teams. Off by default; set `true` to enable, or toggle from Server settings → Advanced. When off, `GET/POST /teams/promptowl` return `404` and the PromptOwl Teams panel is hidden. Independent of `PROMPTOWL_SIGN_IN_GATE`. |
 | `TYPE_ARTIFACT_ENABLED` | `true` | Set `false` to disable creation of **artifact** nodes server-wide (existing artifact nodes stay readable — never data loss). Runnable types (agent/skill/tool) are gated by `FEATURE_WORKFLOW_PLANE`, not here. Also editable from Settings (`/admin/settings`). |
 | `TYPE_TABLE_ENABLED` | `true` | Same as above for **table** nodes. |
+| `HOOTIE_ENABLED` | `true` | Hootie in the nest — the assistant on every page of the UI and its `POST /nests/:id/chat` route. Set `false` to switch it off (the launcher disappears and the route answers `404`). Also toggleable from Settings → General. Answering needs `ANTHROPIC_API_KEY`; without one the feature stays on but the panel explains what's missing and the route answers `503`. Questions are budgeted per user across all nests (30 per 5 minutes); in `AUTH_MODE=open` every caller is the one anonymous user, so the budget is shared by everyone on that server. |
+| `HOOTIE_MODEL` | `claude-opus-5` | The model Hootie answers with. Also editable from Settings → General. Through a gateway, use the gateway's name for it (`ollama/llama3.2`, `gpt-5`, …). |
+| `ANTHROPIC_BASE_URL` | _(unset — Anthropic directly)_ | A LiteLLM or PromptOwl gateway speaking `/v1/messages`. When set, **every** model call this server makes goes through it — Hootie, and agent runs via the run bundle's env floor — with `ANTHROPIC_API_KEY` as the gateway's virtual key: budgets, spend logs, and any model the gateway fronts. Also editable from Settings → General. |
 | `FEATURE_WORKFLOW_PLANE` | _(unset — off)_ | Enables the workflow plane: typed edges, edge-type registry, governed runs. Optional feature; also toggleable from Settings. |
 | `FEATURE_SUBAGENT_RUNS` | _(unset — off)_ | Lets runs spawn nested sub-agent runs (recursion). Gated separately from the plane; requires `FEATURE_WORKFLOW_PLANE`. Also toggleable from Server settings → Advanced (turning the plane off forces this off too). Opens a recursion surface — enable only after reviewing the depth/fan-out caps. |
 | `SUBAGENT_MAX_DEPTH` | `8` | Max sub-agent nesting depth (clamped 1..32) — bounds the call tree's HEIGHT so it stays finite/haltable. |
 | `SUBAGENT_MAX_CHILDREN` | `16` | Max direct children a single run may spawn (clamped 1..128) — bounds the call tree's WIDTH. Together with `SUBAGENT_MAX_DEPTH` this caps total tree size so a runner can't fork-bomb the DB. |
 | `RUN_MAX_STEPS` | `10000` | Max steps a single run may accumulate (clamped 10..100000) — bounds a runaway/hostile runner's step log. |
 | `RUN_MAX_CONCURRENT_ROOTS` | `50` | Max concurrently-running root (depth-0) runs per nest (clamped 1..1000). The subagent caps bound a single tree; this bounds how many trees can run at once, so triggers can't flood a nest. |
-| `ANTHROPIC_API_KEY` | _(unset)_ | Server-wide default runner key for workflow-plane agent runs. Never returned by the API — the health endpoint reports presence only, and Settings shows a masked tail. |
+| `ANTHROPIC_API_KEY` | _(unset)_ | Server-wide default runner key for workflow-plane agent runs, and the key Hootie answers with. Never returned by the API — the health endpoint reports presence only, and Settings shows a masked tail. |
+| `SECRETS_KEY` | _(unset — a key is generated and stored in the database)_ | Master key for the credentials this server stores encrypted (the secret settings rows and every nest Tool-environment value). Any string; it is hashed to 32 bytes. Optional, and stronger than the default when your deployment has a secret manager: the key then lives outside the database it protects. Values already written under the generated key cannot be read after you set it. See [Runtime settings persistence](#runtime-settings-persistence). |
 | `SLACK_WEBHOOK_URL` | _(unset — connector off)_ | Slack incoming-webhook URL for governance-event notifications (review submitted/approved/rejected, collaborator added). `https://` only — the URL embeds a secret. Also editable from Settings in the UI. |
 | `MSTEAMS_WEBHOOK_URL` | _(unset — connector off)_ | Microsoft Teams incoming-webhook URL for the same governance events, posted as Adaptive Cards. `https://` only — the URL embeds a secret. Also editable from Settings in the UI. See [Microsoft Teams notifications](#microsoft-teams-notifications). |
 | `EMAIL_PROVIDER` | `smtp` | Email transport: `smtp` (uses `SMTP_URL`) or `ses` (AWS SES through the AWS SDK, for servers that can't use SMTP). Also editable from Settings. |
@@ -875,6 +879,33 @@ to keys you don't set in the environment stay put. Clearing a setting in the UI
 writes a tombstone, so a value you removed is not resurrected from the environment
 on the next boot.
 
+**Credentials are encrypted at rest.** The secret rows — `ANTHROPIC_API_KEY`,
+`OIDC_CLIENT_SECRET`, `MCP_SIGNING_SECRET`, `SMTP_URL`, `SLACK_WEBHOOK_URL`,
+`MSTEAMS_WEBHOOK_URL`, `SES_SECRET_ACCESS_KEY`, `PROMPTOWL_KEY` — and every value in a
+nest's Tool environment (`nest_env`) are stored AES-256-GCM encrypted, so a row read in
+isolation is not the credential. Non-secret settings stay readable: what a server is
+configured to do is worth being able to see. One known exception: the license
+validation cache (`license_cache`) is still keyed by the license key itself.
+
+The master key needs nothing configured: on first use the server generates one and
+stores it in the database (`server_settings`, key `SECRETS_MASTER_KEY`), so it survives
+redeploys, is shared by every instance, and travels with your database backups. That row
+is not a setting — it is never loaded into the process environment and never returned by
+the settings API.
+
+Set **`SECRETS_KEY`** in the deploy environment to supply the key yourself instead; it
+takes precedence over the stored one, and any string works (it is hashed to 32 bytes).
+This is the stronger arrangement, because the key then lives somewhere the database is
+not: a database dump alone cannot open the values. With the stored key, a dump that
+includes that row includes the key — the encryption protects against a value being read
+or logged incidentally, not against an attacker holding the whole database. If you set
+`SECRETS_KEY` on a server that already wrote values under the stored key, it cannot read
+them: the server still boots, logs which settings it could not open, and treats each as
+unset so an admin can re-enter it.
+
+Values written before any of this existed are read back as plaintext and re-encrypted the
+next time they are saved — nothing to migrate.
+
 ### Cloud Run + Cloud SQL (PostgreSQL)
 
 Attach the Cloud SQL instance to the service (`--add-cloudsql-instances`) so the

package/dist/{chunk-TRSGPS27.js → chunk-H3W72HN3.js}

@@ -501,6 +501,34 @@ var config = {
   get TYPE_TABLE_ENABLED() {
     return process.env.TYPE_TABLE_ENABLED !== "false";
   },
+  /**
+   * Hootie in the nest: the floating assistant on every page of the UI and
+   * its POST /nests/:id/chat route (default ON). Superadmin-editable at
+   * runtime via /admin/settings (hootie_enabled). Off → the route 404s and
+   * the launcher is hidden. Answering additionally needs the server-wide
+   * ANTHROPIC_API_KEY; without one the route answers 503, not 404 — the
+   * feature is on, it just isn't configured yet.
+   */
+  get HOOTIE_ENABLED() {
+    return process.env.HOOTIE_ENABLED !== "false";
+  },
+  /** Model Hootie answers with. Superadmin-editable at runtime via
+   *  /admin/settings (hootie_model). A gateway-side name (`ollama/…`,
+   *  `gpt-…`) is fine when ANTHROPIC_BASE_URL points at one. */
+  get HOOTIE_MODEL() {
+    return process.env.HOOTIE_MODEL || "claude-opus-5";
+  },
+  /**
+   * Where the Anthropic-shaped model calls go. Empty = Anthropic directly.
+   * Set to a LiteLLM (or PromptOwl) gateway to route Hootie AND agent runs
+   * through it — one setting: the runner honours the same variable via the
+   * run bundle's env floor. Superadmin-editable (anthropic_base_url).
+   * Never a per-user vendor key: that is the shadow-AI hole the gateway
+   * exists to close.
+   */
+  get ANTHROPIC_BASE_URL() {
+    return (process.env.ANTHROPIC_BASE_URL || "").trim().replace(/\/$/, "");
+  },
   /**
    * Sub-agent runs: lets a run spawn nested runs (an external runner calling
    * back into POST /run for a child agent). Gated SEPARATELY from the base

package/dist/{chunk-DGPTJXIV.js → chunk-MB52DWWP.js}

@@ -7,7 +7,7 @@ import {
   resolveNestAccess,
   resolveNestPermission,
   resolveTeamRolesForUser
-} from "./chunk-SWA5M5XX.js";
+} from "./chunk-QMQDWRHN.js";
 import {
   ConflictError,
   ValidationError
@@ -19,12 +19,12 @@ import {
   collabPermToRole,
   primaryRole,
   sendEmailToRecipient
-} from "./chunk-I5EDEZBQ.js";
+} from "./chunk-RXCVXG34.js";
 import {
   config,
   getDb,
   isEmailish
-} from "./chunk-TRSGPS27.js";
+} from "./chunk-H3W72HN3.js";
 
 // src/governance/stewardship-service.ts
 import { v4 as uuid } from "uuid";
@@ -233,7 +233,7 @@ async function createStewardRecord(params) {
     );
     let userId = userRow?.id;
     if (!userId) {
-      const { findOrCreateInvitedUser } = await import("./invited-user-AM6A3WGO.js");
+      const { findOrCreateInvitedUser } = await import("./invited-user-XEBX6BM4.js");
       userId = (await findOrCreateInvitedUser(email)).id;
     }
     const created = await assignSteward({

package/dist/{chunk-IEAWRHMV.js → chunk-NFFUZF2B.js}

@@ -2,13 +2,13 @@ import {
   buildTitleMap,
   insertOrReplace,
   nowExpr
-} from "./chunk-SWA5M5XX.js";
+} from "./chunk-QMQDWRHN.js";
 import {
   ValidationError
 } from "./chunk-LHWOJPFE.js";
 import {
   getDb
-} from "./chunk-TRSGPS27.js";
+} from "./chunk-H3W72HN3.js";
 
 // src/governance/version-service.ts
 import { createHash } from "crypto";
@@ -215,6 +215,25 @@ async function setApprovedVersion(nestId, nodeId, version, approvedBy) {
   );
   await db.run(sql, [nestId, nodeId, version, approvedBy]);
 }
+var APPROVED_HEAL_AUTHOR = "system:approved-heal";
+async function moveApprovedVersion(nestId, nodeId, from, to) {
+  const db = getDb();
+  const moved = await db.run(
+    `UPDATE approved_versions
+        SET approved_version = ?, approved_by = ?, approved_at = ${nowExpr(db)}
+      WHERE nest_id = ? AND node_id = ? AND approved_version = ?`,
+    [to, APPROVED_HEAL_AUTHOR, nestId, nodeId, from]
+  );
+  if (moved.changes === 0) return false;
+  const note = `Approved version moved from v${from} to v${to} \u2014 v${from} could not be rebuilt`;
+  await db.run(
+    `UPDATE node_versions
+        SET change_note = CASE WHEN change_note IS NULL OR change_note = '' THEN ? ELSE change_note || ' \xB7 ' || ? END
+      WHERE nest_id = ? AND node_id = ? AND version = ?`,
+    [note, note, nestId, nodeId, to]
+  );
+  return true;
+}
 async function getSealedVersion(nestId, nodeId) {
   const approved = await getApprovedVersion(nestId, nodeId);
   if (approved != null) return approved;
@@ -458,6 +477,8 @@ export {
   getApprovedVersion,
   getApprovedVersions,
   setApprovedVersion,
+  APPROVED_HEAL_AUTHOR,
+  moveApprovedVersion,
   getSealedVersion,
   deleteSupersededDrafts,
   deleteUnsealedVersions,

package/dist/{chunk-PICUHQEM.js → chunk-O3JEI33N.js}

@@ -1,10 +1,10 @@
 import {
   sendEmailToRecipient
-} from "./chunk-I5EDEZBQ.js";
+} from "./chunk-RXCVXG34.js";
 import {
   config,
   getDb
-} from "./chunk-TRSGPS27.js";
+} from "./chunk-H3W72HN3.js";
 import {
   normalizeEmail
 } from "./chunk-FRQJWGN3.js";

package/dist/{chunk-SWA5M5XX.js → chunk-QMQDWRHN.js}

@@ -8,12 +8,12 @@ import {
   permissionLabel,
   sendEmailToRecipient,
   teamRoleToPermission
-} from "./chunk-I5EDEZBQ.js";
+} from "./chunk-RXCVXG34.js";
 import {
   config,
   getDb,
   isEmailish
-} from "./chunk-TRSGPS27.js";
+} from "./chunk-H3W72HN3.js";
 import {
   ANON_USER_ID
 } from "./chunk-YB3LKF7U.js";
@@ -156,6 +156,102 @@ function insertOrReplace(db, insertSql, conflictCols, set) {
   return db.dialect === "sqlite" ? insertSql.replace(/^\s*INSERT\s+INTO/i, "INSERT OR REPLACE INTO") : `${insertSql} ON CONFLICT (${conflictCols.join(", ")}) DO UPDATE SET ${set}`;
 }
 
+// src/shared/secret-box.ts
+import {
+  createCipheriv,
+  createDecipheriv,
+  createHash as createHash2,
+  randomBytes
+} from "crypto";
+var PREFIX = "enc.v1.";
+var b64 = (b) => b.toString("base64url");
+var MASTER_KEY_SETTING = "SECRETS_MASTER_KEY";
+var SECRET_SETTINGS = /* @__PURE__ */ new Set([
+  "ANTHROPIC_API_KEY",
+  "OIDC_CLIENT_SECRET",
+  "MCP_SIGNING_SECRET",
+  "SMTP_URL",
+  "SLACK_WEBHOOK_URL",
+  "MSTEAMS_WEBHOOK_URL",
+  "SES_SECRET_ACCESS_KEY",
+  "PROMPTOWL_KEY"
+]);
+function isSecretSetting(name) {
+  return SECRET_SETTINGS.has(name);
+}
+function isEncrypted(value) {
+  return value.startsWith(PREFIX);
+}
+async function encryptSecret(plain) {
+  if (isEncrypted(plain)) return plain;
+  const iv = randomBytes(12);
+  const cipher = createCipheriv("aes-256-gcm", await masterKey(), iv);
+  const ct = Buffer.concat([cipher.update(plain, "utf8"), cipher.final()]);
+  return PREFIX + [b64(iv), b64(cipher.getAuthTag()), b64(ct)].join(".");
+}
+async function decryptSecret(stored) {
+  if (!isEncrypted(stored)) return stored;
+  const [iv, tag, ct] = stored.slice(PREFIX.length).split(".");
+  if (!iv || !tag || !ct) throw new Error("malformed encrypted value");
+  const decipher = createDecipheriv(
+    "aes-256-gcm",
+    await masterKey(),
+    Buffer.from(iv, "base64url")
+  );
+  decipher.setAuthTag(Buffer.from(tag, "base64url"));
+  return Buffer.concat([
+    decipher.update(Buffer.from(ct, "base64url")),
+    decipher.final()
+  ]).toString("utf8");
+}
+async function tryDecryptSecret(stored, label) {
+  try {
+    return await decryptSecret(stored);
+  } catch {
+    console.error(
+      `[secrets] cannot decrypt ${label} \u2014 SECRETS_KEY does not match the key this value was written with. Unset it to fall back to the stored key, or re-enter the value to replace it.`
+    );
+    return null;
+  }
+}
+var cached = null;
+var inFlight = null;
+async function masterKey() {
+  const fromEnv = (process.env.SECRETS_KEY || "").trim();
+  if (fromEnv) {
+    if (cached?.id !== fromEnv) {
+      cached = { id: fromEnv, key: createHash2("sha256").update(fromEnv).digest() };
+    }
+    return cached.key;
+  }
+  const db = getDb();
+  const id = `db:${db.dialect}:${dbIdentity(db)}`;
+  if (cached?.id === id) return cached.key;
+  if (!inFlight) inFlight = loadOrCreateKey(id).finally(() => inFlight = null);
+  return inFlight;
+}
+async function loadOrCreateKey(id) {
+  const db = getDb();
+  const read = async () => await db.get("SELECT value FROM server_settings WHERE key = ?", [
+    MASTER_KEY_SETTING
+  ]);
+  let row = await read();
+  if (!row?.value) {
+    const sql = db.dialect === "sqlite" ? `INSERT OR IGNORE INTO server_settings (key, value, env_at_write, updated_at)
+           VALUES (?, ?, NULL, ${nowExpr(db)})` : `INSERT INTO server_settings (key, value, env_at_write, updated_at)
+           VALUES (?, ?, NULL, ${nowExpr(db)}) ON CONFLICT (key) DO NOTHING`;
+    await db.run(sql, [MASTER_KEY_SETTING, randomBytes(32).toString("hex")]);
+    row = await read();
+  }
+  if (!row?.value) throw new Error("could not establish an encryption key");
+  const key = Buffer.from(row.value, "hex");
+  cached = { id, key };
+  return key;
+}
+function dbIdentity(db) {
+  return process.env.DATABASE_URL || process.env.DATA_ROOT || db.dialect;
+}
+
 // src/db/settings.ts
 var deployBaseline = null;
 function norm(v) {
@@ -168,6 +264,9 @@ function baseline() {
 async function persistSetting(name, value) {
   const db = getDb();
   const envAtWrite = norm(baseline()[name]);
+  const seal = async (v) => v !== null && isSecretSetting(name) ? await encryptSecret(v) : v;
+  const sealedValue = await seal(value);
+  const sealedBaseline = await seal(envAtWrite);
   await db.run(
     insertOrReplace(
       db,
@@ -176,7 +275,7 @@ async function persistSetting(name, value) {
       ["key"],
       `value = excluded.value, env_at_write = excluded.env_at_write, updated_at = ${nowExpr(db)}`
     ),
-    [name, value, envAtWrite]
+    [name, sealedValue, sealedBaseline]
   );
 }
 async function loadServerSettings() {
@@ -188,7 +287,12 @@ async function loadServerSettings() {
   );
   let applied = 0;
   for (const row of rows) {
+    if (row.key === MASTER_KEY_SETTING) continue;
     const envVal = norm(base[row.key]);
+    if (isSecretSetting(row.key)) {
+      row.value = row.value === null ? null : await tryDecryptSecret(row.value, row.key);
+      row.env_at_write = row.env_at_write === null ? null : await tryDecryptSecret(row.env_at_write, `${row.key} (baseline)`);
+    }
     if (envVal !== norm(row.env_at_write)) {
       await persistSetting(row.key, envVal);
       if (envVal === null) delete process.env[row.key];
@@ -317,15 +421,15 @@ function getSuspensionReason() {
 var REJECTION_STRIKES_TO_REVOKE = 3;
 var rejectionStreak = 0;
 var rejectionKey = null;
-function fromCache(cached) {
+function fromCache(cached2) {
   return {
     valid: true,
-    tier: cached.tier,
-    org: cached.org,
-    limits: cached.limits_json ? JSON.parse(cached.limits_json) : null,
+    tier: cached2.tier,
+    org: cached2.org,
+    limits: cached2.limits_json ? JSON.parse(cached2.limits_json) : null,
     suspended: suspensionConfirmed,
     suspendedReason: suspensionReason,
-    ownerEmail: cached.owner_email || null
+    ownerEmail: cached2.owner_email || null
   };
 }
 async function validateLicense(opts = {}) {
@@ -347,14 +451,14 @@ async function _validateLicenseImpl(forceFresh, strict) {
     };
   }
   const db = getDb();
-  const cached = await db.get(
+  const cached2 = await db.get(
     "SELECT * FROM license_cache WHERE key = ?",
     [key]
   );
-  if (cached && !forceFresh) {
-    const age = Date.now() - (/* @__PURE__ */ new Date(cached.validated_at + "Z")).getTime();
+  if (cached2 && !forceFresh) {
+    const age = Date.now() - (/* @__PURE__ */ new Date(cached2.validated_at + "Z")).getTime();
     if (age < CACHE_TTL_MS) {
-      return fromCache(cached);
+      return fromCache(cached2);
     }
   }
   try {
@@ -365,11 +469,11 @@ async function _validateLicenseImpl(forceFresh, strict) {
       body: JSON.stringify({ key })
     });
     if (!res.ok) {
-      if (cached) {
+      if (cached2) {
         console.warn(
           "  PromptOwl unreachable, using cached license (grace period)"
         );
-        return fromCache(cached);
+        return fromCache(cached2);
       }
       return {
         valid: false,
@@ -418,7 +522,7 @@ async function _validateLicenseImpl(forceFresh, strict) {
       if (data.valid !== true) {
         rejectionStreak = 0;
         rejectionKey = null;
-        if (cached) return fromCache(cached);
+        if (cached2) return fromCache(cached2);
         return {
           valid: false,
           tier: "none",
@@ -438,14 +542,14 @@ async function _validateLicenseImpl(forceFresh, strict) {
       suspensionReason = null;
     }
     if (!data.valid && !data.suspended) {
-      if (cached && !strict) {
+      if (cached2 && !strict) {
         rejectionStreak = rejectionKey === key ? rejectionStreak + 1 : 1;
         rejectionKey = key;
         if (rejectionStreak < REJECTION_STRIKES_TO_REVOKE) {
           console.warn(
             `[license] PromptOwl rejected the license (${rejectionStreak}/${REJECTION_STRIKES_TO_REVOKE}); keeping the cached license until the rejection is confirmed`
           );
-          return fromCache(cached);
+          return fromCache(cached2);
         }
       }
       rejectionStreak = 0;
@@ -492,11 +596,11 @@ async function _validateLicenseImpl(forceFresh, strict) {
       ownerEmail: data.owner_email || null
     };
   } catch (err) {
-    if (cached) {
+    if (cached2) {
       console.warn(
         `  PromptOwl validation failed (${err.message}), using cached license`
       );
-      return fromCache(cached);
+      return fromCache(cached2);
     }
     return {
       valid: false,
@@ -1057,7 +1161,7 @@ async function resolveMemberIdentity(params) {
   if (!requested) {
     throw new ValidationError("user_id or email is required");
   }
-  const { findOrCreateInvitedUser } = await import("./invited-user-AM6A3WGO.js");
+  const { findOrCreateInvitedUser } = await import("./invited-user-XEBX6BM4.js");
   const { id } = await findOrCreateInvitedUser(requested);
   return { userId: id, email: requested };
 }
@@ -2170,8 +2274,8 @@ async function ensureNodeIndex(nestId) {
   return run;
 }
 async function rebuildNodeIndex(nestId) {
-  const { engineCache: engineCache2 } = await import("./engine-QNMFDIBV.js");
-  const { documentsWithSuggestions } = await import("./external-edit-service-4MEGPT4D.js");
+  const { engineCache: engineCache2 } = await import("./engine-HLYQLP5T.js");
+  const { documentsWithSuggestions } = await import("./external-edit-service-3DFQ4EZZ.js");
   const { storage, dropDiscoveryCache } = await engineCache2.get(nestId);
   dropDiscoveryCache();
   const startedAt = writeGeneration.get(nestId) ?? 0;
@@ -2429,6 +2533,8 @@ export {
   insertOrReplace,
   trackEvent,
   startTelemetryLoop,
+  encryptSecret,
+  tryDecryptSecret,
   persistSetting,
   loadServerSettings,
   getCurrentLicense,

package/dist/{chunk-I5EDEZBQ.js → chunk-RXCVXG34.js}

@@ -1,7 +1,7 @@
 import {
   config,
   getDb
-} from "./chunk-TRSGPS27.js";
+} from "./chunk-H3W72HN3.js";
 
 // src/governance/roles.ts
 function collabPermToRole(permission) {

package/dist/{chunk-2QOJE7A5.js → chunk-SE5U4J4T.js}

@@ -6,10 +6,10 @@ import {
   markIndexStale,
   resolveNestPath,
   syncSuggestionRows
-} from "./chunk-SWA5M5XX.js";
+} from "./chunk-QMQDWRHN.js";
 import {
   getDb
-} from "./chunk-TRSGPS27.js";
+} from "./chunk-H3W72HN3.js";
 
 // src/governance/external-edit-service.ts
 import { readFile, readdir } from "fs/promises";
@@ -83,7 +83,7 @@ async function scanDocumentForDriftInternal(nestId, documentId, actor) {
   if (await bodyMatchesLatestVersion(storage, documentId, drift.actualHash)) {
     return null;
   }
-  const { hasUnsealedDraft } = await import("./version-service-C3JTZLJH.js");
+  const { hasUnsealedDraft } = await import("./version-service-JYHFPSYP.js");
   if (await hasUnsealedDraft(nestId, documentId)) {
     return null;
   }
@@ -254,7 +254,7 @@ async function listExternalEditVerdicts(nestId, documentId) {
 async function mirrorVersion(input) {
   const { storage } = await engineCache.get(input.nestId);
   const node = await storage.readDocument(input.documentId);
-  const { upsertVersion, setApprovedVersion } = await import("./version-service-C3JTZLJH.js");
+  const { upsertVersion, setApprovedVersion } = await import("./version-service-JYHFPSYP.js");
   await upsertVersion({
     nestId: input.nestId,
     nodeId: input.documentId,

package/dist/{chunk-RPGFHESR.js → chunk-VHEMGQ3I.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-LHWOJPFE.js";
 import {
   getDb
-} from "./chunk-TRSGPS27.js";
+} from "./chunk-H3W72HN3.js";
 
 // src/governance/grants-service.ts
 import { v4 as uuid } from "uuid";

package/dist/{chunk-M6PGYMBD.js → chunk-VRLAP4HB.js}

@@ -4,23 +4,24 @@ import {
   resolveNestWideRoles,
   resolveStewardsForNode,
   stewardCoverageForUser
-} from "./chunk-DGPTJXIV.js";
+} from "./chunk-MB52DWWP.js";
 import {
   grantCoversNode,
   listUserGrants,
   resolveNodeGrant
-} from "./chunk-RPGFHESR.js";
+} from "./chunk-VHEMGQ3I.js";
 import {
   createVersion,
   getApprovedVersion,
   getApprovedVersions,
   getCurrentVersion,
   setApprovedVersion
-} from "./chunk-IEAWRHMV.js";
+} from "./chunk-NFFUZF2B.js";
 import {
   buildDocContext,
   buildTitleMap,
   describeNode,
+  encryptSecret,
   engineApi,
   engineCache,
   insertOrReplace,
@@ -34,8 +35,9 @@ import {
   opContext,
   prettyFolderPath,
   resolveNestPermission,
-  titleForNode
-} from "./chunk-SWA5M5XX.js";
+  titleForNode,
+  tryDecryptSecret
+} from "./chunk-QMQDWRHN.js";
 import {
   ConflictError,
   NotFoundError,
@@ -45,11 +47,11 @@ import {
   notifyEmailForNest,
   sendEmailToRecipient,
   transportSettings
-} from "./chunk-I5EDEZBQ.js";
+} from "./chunk-RXCVXG34.js";
 import {
   config,
   getDb
-} from "./chunk-TRSGPS27.js";
+} from "./chunk-H3W72HN3.js";
 
 // src/governance/review-service.ts
 import { v4 as uuid2 } from "uuid";
@@ -362,12 +364,18 @@ envRoutes.get("/", requireWorkflowPlane, async (c) => {
   );
   return c.json({
     count: rows.length,
-    env: rows.map((r) => ({
-      key: r.key,
-      value_masked: mask(r.value),
-      updated_by: r.updated_by,
-      updated_at: r.updated_at
-    }))
+    env: await Promise.all(
+      rows.map(async (r) => ({
+        key: r.key,
+        // A value this server can't open still has a name worth listing, so
+        // the admin can see what to re-enter.
+        value_masked: mask(
+          await tryDecryptSecret(r.value, `${r.key} on nest ${nestId}`) ?? ""
+        ),
+        updated_by: r.updated_by,
+        updated_at: r.updated_at
+      }))
+    )
   });
 });
 envRoutes.put("/", requireWorkflowPlane, async (c) => {
@@ -385,11 +393,12 @@ envRoutes.put("/", requireWorkflowPlane, async (c) => {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const by = await resolveCallerEmail(c.get("userId"));
   const db = getDb();
+  const sealed = await encryptSecret(body.value);
   await db.run(
     `INSERT INTO nest_env (nest_id, key, value, updated_by, updated_at)
      VALUES (?, ?, ?, ?, ?)
      ON CONFLICT(nest_id, key) DO UPDATE SET value = ?, updated_by = ?, updated_at = ?`,
-    [nestId, key, body.value, by, now, body.value, by, now]
+    [nestId, key, sealed, by, now, sealed, by, now]
   );
   return c.json({ key, value_masked: mask(body.value) }, 201);
 });
@@ -412,7 +421,16 @@ async function envValues(nestId) {
   );
   const base = {};
   if (process.env.ANTHROPIC_API_KEY) base.ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY;
-  return { ...base, ...Object.fromEntries(rows.map((r) => [r.key, r.value])) };
+  if (config.ANTHROPIC_BASE_URL) base.ANTHROPIC_BASE_URL = config.ANTHROPIC_BASE_URL;
+  const stored = (await Promise.all(
+    rows.map(
+      async (r) => [
+        r.key,
+        await tryDecryptSecret(r.value, `${r.key} on nest ${nestId}`)
+      ]
+    )
+  )).filter((e) => e[1] !== null);
+  return { ...base, ...Object.fromEntries(stored) };
 }
 
 // src/notify/webhook.ts