@promptowl/contextnest-community 1.23.0 → 1.24.0

package/CONFIGURATION.md

@@ -80,6 +80,7 @@ The server prints a loud warning at startup when `AUTH_MODE=open` is active.
 | `POSTHOG_KEY` | `""` | PostHog project API key for product analytics in the UI. Empty = analytics off (the default — a self-hosted install brings its own project). Served to the browser via `/health`, but only while `TELEMETRY_ENABLED` is on, so that switch turns off everything this server sends outward. Also editable from Settings → Advanced. |
 | `POSTHOG_HOST` | `https://us.i.posthog.com` | PostHog ingestion host. Set it to your own region or self-hosted PostHog. Also editable from Settings → Advanced. |
 | `TRACE_RETENTION_DAYS` | `14` | Activity-trace retention window in days (the `api_events` rows behind `GET /admin/trace` and `GET /nests/:id/trace`). Rows older than this are pruned opportunistically (every ~500 inserts). `0` = keep forever (pruning is skipped entirely). Capped at `3650`; invalid/negative values fall back to `14`. Also editable from Settings → Advanced. |
+| `DRIFT_SCAN_INTERVAL_MS` | `30000` (30 s) | How often the drift scanner walks every nest for files edited outside the app (external edits) and stages them as suggestions for review. Set `0` to disable — do this on a GCS FUSE or other network mount, where the walk is slow and costly. Unset, empty or non-numeric falls back to the default. |
 | `CORS_ORIGINS` | `*` in open mode; `http://localhost:5173,http://localhost:3838` in key mode | Comma-separated allowlist. Set to `*` to allow any origin (**only** safe in open mode — in key mode with Bearer tokens this enables CSRF). |
 | `FRAME_ANCESTORS` | `'self'` | Which origins may embed this server in an iframe, sent as CSP `frame-ancestors`. The default lets nothing but this origin frame the UI, which blocks clickjacking. Deployments that are meant to be embedded list the embedding origin — e.g. the PromptOwl Data Room iframes ContextNest, so that install sets `FRAME_ANCESTORS="https://app.promptowl.ai"`. Comma-separated; `'self'` is always included; `*` allows any site and disables the protection. Note the embedding page must be **same-site** (a sibling subdomain) for the session cookie to survive inside the frame — a genuinely cross-domain embed will render the login page no matter what this is set to. |
 | `MAX_BODY_BYTES` | `10485760` (10 MB) | Reject requests whose `Content-Length` exceeds this. Prevents giant-payload DoS. The asset-upload route (`POST /nests/:id/assets`) is exempt up to the video cap below. |

package/README.md

@@ -8,17 +8,19 @@
 
 ## What it is
 
-ContextNest Community Edition is a self-hosted server that lets you:
+A shared knowledge base for your team **and** your AI agents, running on your own machine or infrastructure. Documents live in **nests**; every save is a version; in a stewarded nest a change waits for a reviewer before agents can read it. People write in the browser, agents read and write the same documents over MCP, HTTP or the `ctx` CLI.
 
-- Store, version, and govern markdown-based context documents ("nests"), filed in folders you can reorganize as the vault grows
-- Import an existing folder or vault of markdown files in one step
-- Export a nest as a portable bundle and re-import it on another self-hosted host
-- Apply stewardship workflows — draft, pending review, approved
-- Share nests with collaborators or publish them read-only to the public
-- Serve approved context to AI agents via MCP or HTTP — connect one by pasting a generated setup prompt or downloading a ready `.env`, or register the nest in the ctx CLI (`ctx vault add <alias> --url <server>/nests/<id>/mcp --bearer-env CONTEXTNEST_API_KEY`, then `ctx query "#tag" --vault <alias>`)
-- Sync with the PromptOwl hosted platform for multi-user collaboration
+Concretely, it lets you:
 
-The server runs locally or on your own infrastructure. Your PromptOwl account handles authentication, entitlement, and governance metadata.
+- Write Markdown documents — plus hosted HTML artifacts and CSV tables agents can query row by row — filed in folders, linked with `[[Title]]`, tagged, commented on, and versioned
+- Import an existing folder of Markdown in one step; export a nest as a portable bundle
+- Govern changes — draft → pending review → approved — with stewards per nest, tag or document, and a cross-nest inbox (My Work, My Drafts) for what is waiting on you
+- Share a nest with people or teams, share a single document or folder, or publish read-only to the public
+- Give agents deterministic reads: the same selector returns the same context every time, with a trace of what was pulled
+- Run agents against a nest (Workflows, Beta): an agent is a document whose body is instructions; its output lands as a pending review
+- Sync with the PromptOwl hosted platform for accounts, licensing and teams
+
+Your PromptOwl account handles authentication, entitlement, and governance metadata.
 
 ## Quickstart
 
@@ -73,6 +75,40 @@ The key is read at boot. The server validates against PromptOwl on startup; if v
 
 For redistribution, hosted-service, OEM, or regulated-industry licensing, contact **hoot@promptowl.ai**.
 
+## First five minutes
+
+1. **Create a nest** on the Nests page — or **Import folder** to bring in Markdown you already have.
+2. **Write a document.** `[[Title]]` links another document, `@name` mentions a person, tags go under the title. Every save is a version.
+3. **Turn on stewardship** (nest Settings) if you want review. Saves become drafts; **Submit for review**; a steward approves or rejects. Alone? Allow self-approve and you get the history without the ceremony.
+4. **Connect an agent.** Inside a nest, **Connect** (bottom of the sidebar) gives you the MCP URL and a REST snippet; **Add with AI** (nest overview) is a prompt that has an agent write context in. Mint a key under Workspace → API keys.
+5. **Share.** The whole nest with a person or team, one document or folder, or make it public with a read-only Reader mode.
+
+The in-app **How it works** page (sidebar → Help) is the full tour; **Docs** (header) is the agent manual.
+
+## Around the app
+
+One sidebar, grouped:
+
+| Group | Pages | Who |
+|---|---|---|
+| — | **Nests** — every nest you can see, pinned first | everyone |
+| Work | **My Work** (reviews and handoffs waiting on you, across nests) · **My Drafts** (yours, never submitted) | everyone |
+| Workspace | **Teams** · **API keys** | everyone |
+| Admin | **Teammates** · **Server settings** · **Activity trace** | server admins |
+| Help | **How it works** | everyone |
+
+Inside a nest: the document tree, plus **Board** (documents as cards by folder, status or tag), **Graph** (documents, links, tags, stewards), **Definitions** (the nest's glossary) and **Workflows** (Beta). The user menu (top right) holds **Account** (name, password), keyboard shortcuts and logout. `Ctrl`/`⌘` `K` searches every nest and document; `?` lists shortcuts.
+
+## Connect an agent
+
+Point any agent at `<server>/llms.txt` — it is the complete manual (endpoints, MCP tools, selector grammar). The short version:
+
+- **MCP** — `<server>/mcp` for everything the key can read, `<server>/nests/<id>/mcp` for one nest with the full toolset. Claude Code, Cursor and VS Code connect over HTTP with `Authorization: Bearer cnst_…`; Claude Desktop goes through `npx -y mcp-remote`.
+- **REST** — `POST /nests/<id>/context` with a selector (`#tag`, `[[Title]]`, `type:document`, combined with `+ | -`) returns assembled context plus a trace. Full reference: [API.md](./API.md).
+- **ctx CLI** — `ctx vault add <alias> --url <server>/nests/<id>/mcp --bearer-env CONTEXTNEST_API_KEY`, then `ctx query "#tag" --vault <alias>`.
+
+Keys are minted in the app (Workspace → API keys, or the Connect dialog) — one per client, user-wide or scoped to a nest. Servers in `AUTH_MODE=open` need none.
+
 ## System requirements
 
 - **Node.js** 20.x or later
@@ -105,6 +141,14 @@ For redistribution, hosted-service, OEM, or regulated-industry licensing, contac
 | MCP server for AI agents | ✅ | ✅ |
 | One-shot agent setup — generated connect prompt + `.env` download | ✅ | ✅ |
 | Several API keys per account — one credential per client, rotate one at a time | ✅ | ✅ |
+| Comments on documents — anchored threads, resolve / reopen, same threads over MCP | ✅ | ✅ |
+| Table nodes — CSV facts with deterministic row queries (`POST /table-query`, `context_table_query`) | ✅ | ✅ |
+| Teams — share a nest with a group once; import rosters from PromptOwl | ✅ | ✅ |
+| Cross-nest inbox — My Work (reviews, handoffs) and My Drafts | ✅ | ✅ |
+| Nest views — Board (kanban by folder / status / tag), Graph, Definitions glossary | ✅ | ✅ |
+| Workflow plane (Beta) — agents as documents, runs, schedules, inbound hooks, Slack / Teams / webhook connectors | ✅ | ✅ |
+| Activity trace — every governance action, per nest and server-wide | ✅ | ✅ |
+| Notifications — Slack, Microsoft Teams, email | ✅ | ✅ |
 | Centralized multi-tenant admin console | — | ✅ |
 | Single sign-on (OIDC — Entra ID, Google, Okta, Keycloak) | ✅ | ✅ |
 | SAML / SCIM provisioning | — | ✅ |
@@ -118,6 +162,14 @@ For Enterprise pricing and features, contact **hoot@promptowl.ai** or visit <htt
 
 Release notes live in [CHANGELOG.md](./CHANGELOG.md).
 
+## Documentation
+
+- [CONFIGURATION.md](./CONFIGURATION.md) — every environment variable (port, auth mode, storage, notifications, telemetry)
+- [API.md](./API.md) — complete REST reference with request and response bodies
+- [STEWARDSHIP.md](./STEWARDSHIP.md) — the governance model: modes, stewards, scopes, prime documents, teams, super-admins
+- `<server>/llms.txt` — the agent manual the running server publishes; rendered as **Docs** in the app
+- **How it works** inside the app — a page-by-page tour
+
 ## Licensing
 
 ContextNest Community Edition is **commercial software**. It is **not open source**.

package/STEWARDSHIP.md

@@ -0,0 +1,229 @@
+# Stewardship — Quick Guide
+
+A short, practical guide to the governance model the community server implements. The deep strategy lives in `docs/contextnest-whitepaper.md`; this is the "how does this actually work in the product" version.
+
+## The two modes
+
+Every nest is either **ungoverned** or **governed**, controlled by the `stewardship_enabled` flag on the nest.
+
+| | Ungoverned (default) | Governed |
+|---|---|---|
+| New documents | Auto-approved, immediately available to AI | Start as **drafts**; need steward approval |
+| Draft / pending / rejected lifecycle | Not shown | Shown, filterable |
+| Review queue | Hidden | Visible, orderable |
+| Stewards | Not shown | Assignable by scope |
+| Reads gated by permission | No | Yes (in key mode) |
+
+Flip the flag any time via the nest's **Settings → Stewardship**. Existing approved docs stay approved; existing drafts remain drafts.
+
+## What a steward is
+
+A **steward** is a person (identified by email) who governs a subset of the nest. Stewards have one of three roles:
+
+| Role | Can read | Can edit | Can approve / reject |
+|---|---|---|---|
+| **Viewer** | yes | no | no |
+| **Editor** | yes | yes | no |
+| **Reviewer** | yes | yes | **yes** |
+
+> **Authors can't approve their own work.** Even a reviewer-level steward can't approve a version they themselves authored. Separation of duties, enforced server-side.
+
+## Scope — who governs what
+
+Stewards are assigned at one of three scopes. When a document needs a steward (to approve, or to check access), the server resolves them in this order — **first match wins**:
+
+| Priority | Scope | Target | Example |
+|---|---|---|---|
+| 1 | **Document** | Exact node id | `nodes/pricing-policy` — only this one doc |
+| 2 | **Tag** | Tag name (lowercased, no `#`) | `security` — any doc tagged `#security` |
+| 3 | **Nest** | (none — applies to the whole nest) | The fallback for anything not covered above |
+
+If nothing matches and no steward resolves, the **nest owner** is the implicit steward (owner fallback). That keeps a freshly-enabled nest workable even with zero stewards configured.
+
+## The approval flow
+
+1. **Author** creates or edits a doc. In governed mode it saves as a **draft**.
+2. **Author** clicks **Submit for Review**. The doc becomes **pending** and appears in the review queue for anyone whose scope resolves to that doc — and in their **My Work** page across nests. Until someone acts the author can withdraw it back to draft.
+3. A **Reviewer steward** opens the review queue (or My Work), reads the doc, clicks **Approve** or **Reject**. Rejecting requires a note.
+4. On approve, the doc becomes **approved** and is now AI-readable. The approved version number is pinned (`approvedVersion`), so subsequent drafts don't automatically replace it — AI keeps getting the last blessed version until a new one is approved.
+
+### Auto-publish owner & admin edits (`allow_self_approve`)
+
+A per-nest flag (**off** by default; nest Settings → "Auto-publish owner & admin edits"). When it's **on**, a create or edit by the nest **owner** or an **admin** publishes immediately — it skips steps 2–4 entirely instead of landing as a draft. This is a governance *bypass* for the two roles that already hold approval authority, not a separation-of-duties exception. **Editor and reviewer flows are unchanged**: their edits still save as drafts and go through Submit → Review → Approve regardless of the flag. The pending-review edit lock still applies, so an owner/admin can't overwrite a doc a teammate has in review. Turning the flag back off doesn't unpublish anything; it only affects future edits.
+
+## Prime documents
+
+Most content in a nest doesn't need a review gate — call notes, social drafts, scratch research. A small set does: messaging architecture, the sales playbook, pricing policy. **Prime** marks that second set.
+
+A prime document **always** goes through draft → pending → approved, no matter who writes it. It is the one thing `allow_self_approve` does not bypass: an owner editing a prime document still lands a draft.
+
+### How a document becomes prime
+
+Resolution mirrors the steward scope order — **document → tag → nest**, first match wins:
+
+| Priority | Scope | How it's set |
+|---|---|---|
+| 1 | **Document** | The Prime switch in the document editor (owner/admin only). `true` forces prime; `false` **exempts** this one doc from an otherwise-prime tag. |
+| 2 | **Tag** | The doc carries one of the nest's **prime tags** (Settings → Prime tags; `prime-document` out of the box). |
+| 3 | **Nest** | Nothing matched → not prime. |
+
+Only the nest owner or an admin can set or clear the document flag — it's a governance decision, not an authoring one. Otherwise any editor could un-flag the playbook and walk their own edit past the gate.
+
+### Reviewing prime documents only (`prime_only_review`)
+
+A per-nest flag (**off** by default; nest Settings → "Review prime documents only"). It changes what a governed nest's *default* is:
+
+| | `prime_only_review` off (default) | on |
+|---|---|---|
+| Ordinary document, any author | Draft → review → approve (unless the author has a self-approve bypass) | **Publishes immediately** |
+| Prime document, any author | Draft → review → approve | Draft → review → approve |
+
+That's the "most content self-publishes, high-stakes content is gated" posture. Leaving it off preserves the original behaviour, so turning stewardship on doesn't silently change meaning for an existing nest.
+
+While `prime_only_review` is on, `allow_self_approve` has no effect at all — non-prime documents already publish for everyone, and prime documents ignore the bypass. Settings disables that switch and says so rather than leaving a live control that changes nothing.
+
+Prime only applies to **governed** nests. With stewardship off there are no stewards to approve anything, so a prime tag is inert until you turn stewardship on.
+
+### At a glance
+
+Prime documents carry a **Prime** badge in the nest's document list, with a tooltip saying whether it came from the document flag or an inherited tag. To see every document a given prime tag covers, filter the list by that tag.
+
+Flipping any of this only affects **future** writes. Marking a published document prime doesn't unpublish it; the next edit is what needs approval.
+
+## Who sees what
+
+Governance gates two things: who can **approve**, and who can **read**.
+
+- **Approve gate**: server-side, always on when stewardship is enabled. Non-stewards can't approve.
+- **Read gate**: only active in **key mode** (`AUTH_MODE=key`, real user accounts with API keys). In **open mode** — which is the default for a solo/local server — everyone is the same anonymous admin, so read-gating is a no-op.
+
+In key mode, when stewardship is enabled on a nest:
+- Node list / single-read / search / query responses are filtered to docs the caller can access
+- A non-steward gets an empty list or a 403 on the node they asked for
+- The nest **owner** and any resolved **steward (any role)** can read; **super admins** bypass the check
+
+## Server super-admins
+
+Super-admins administer **every** nest on the server without being added per-nest. The effective set is the union of three sources:
+
+- **license** — the PromptOwl account that owns the installed license (always; never revocable)
+- **config** — emails in `access.yaml: super_admins` (the bootstrap; edit the file + restart to change)
+- **granted** — grants managed from **Teammates → Superadmins** in the UI, or `GET/POST /admin/super-admins` (see `API.md`)
+
+A super-admin can:
+
+- Read every document (bypasses the read gate, even with stewardship enabled)
+- Change a nest's visibility (private / org / public)
+- Add, remove, and re-role collaborators
+- Add, remove, and re-role stewards
+- Approve and reject pending versions in any nest's review queue
+- Manage the official community sites trusted for SSO auto-login (**Server settings → Community sites**, or `GET/POST /admin/community-sites` — see `API.md`)
+
+What a super-admin **cannot** do (owner-only operations):
+
+- Delete a nest
+- Transfer ownership
+
+Use this for a small set of platform operators — a CEO, a head of governance, an internal compliance admin — not as a default broad-access mechanism. Day-to-day governance should still flow through per-nest stewards.
+
+## Teams — sharing with a group
+
+Instead of adding people one at a time, you can create a **team** — a reusable,
+owner-managed group — and share it onto a nest. Each team member carries a
+**role** set on the membership (not on the share), and that role applies on
+**every** nest the team is shared to:
+
+| Member role | Nest access | Governance |
+|---|---|---|
+| **viewer** | read | viewer |
+| **editor** | write | editor |
+| **admin** | admin | admin |
+
+Key points:
+
+- A member's role is uniform across nests — set it once on the team. To vary
+  access per nest, use a different team (or a direct collaborator/steward grant).
+- When a user reaches a nest by several paths (a direct collaborator grant **and**
+  team membership), the **highest** access wins.
+- Sharing a team whose members carry a governance role (viewer/editor)
+  **enables stewardship** on the nest — same effect as assigning an individual
+  steward. An `admin`-only team is collaborator-style and doesn't.
+- Removing a member, deleting the team, or unsharing it **revokes access
+  immediately** — there are no per-user rows to clean up.
+- Managing a team is gated by your role on it: editor/admin members (and the
+  owner) can add people, capped to their own level; admins can also change
+  roles and remove members; only the owner can delete the team.
+
+### Importing a team from PromptOwl
+
+If you already run teams in PromptOwl, the Teams page has a **PromptOwl Teams**
+tab listing your teams there with their members. Each one has a **Sync** button
+that copies it here as a normal team owned by you, instead of you retyping every
+member. Members without an account here become invited placeholders, exactly as
+if you'd added them by hand.
+
+**The tab only appears if you signed in with PromptOwl** — that sign-in is what
+gives this server permission to read your teams. Signing in another way (SSO,
+your identity provider, or email and password) means no PromptOwl identity to
+read teams for, so the tab isn't offered.
+
+**You can import a team you're an owner or editor of in PromptOwl.** Teams you're
+view-only on are listed for reference but can't be imported: the copy would be
+yours to control here — rename it, rewrite its roster, share it onto a nest —
+and that's more than PromptOwl lets you do with that team. Ask one of its owners
+or editors to import it instead.
+
+Already-imported teams are marked **Synced** in that tab, and show a **PromptOwl**
+badge in the ContextNest Teams tab. Two things worth knowing before you sync
+one again:
+
+- **PromptOwl is the source of truth on every sync.** The roster is reconciled to
+  match: roles are reset, and anyone no longer in the PromptOwl team is removed —
+  including people you added to this team by hand here. If you need a group that
+  differs from PromptOwl, make it a separate team rather than editing an
+  imported one.
+- **Your PromptOwl access isn't stored on this server.** The connection lives in
+  a cookie in your own browser and ends when your session does — this server's
+  database never holds anything that can reach your PromptOwl account, so a
+  stolen backup of it exposes nothing of yours. The connection is also limited
+  to reading your profile and your teams: it cannot chat as you or spend your
+  credits. Signing out ends it, and revoking the device in PromptOwl's account
+  settings ends it immediately from the other side.
+
+PromptOwl's `User` role — its default membership — maps to **viewer** here, as
+does any role this version doesn't recognize; `Owner` maps to admin, and
+`Editor`/`Viewer` map across as themselves.
+
+Members see the teams they belong to on the **Teams** page and any team-shared
+nest on their dashboard. Manage teams there (create, add/remove members with a
+role); share them from a nest's sharing panel. See `API.md` §3a for the endpoints.
+
+## Picking a scope when you assign a steward
+
+Rules of thumb:
+
+- **Nest scope** — use sparingly. "This person reviews everything in this nest."
+- **Tag scope** — the most common. "Legal reviews anything with `#legal`. Security reviews `#auth` and `#pii`."
+- **Document scope** — override. "This specific doc has a dedicated reviewer regardless of its tags."
+
+You can stack them: a doc tagged `#legal` can have a doc-level steward that overrides the tag steward. Priority order resolves ties.
+
+## `stewards.yaml` (optional)
+
+You can also declare stewards declaratively via a `stewards.yaml` file in the nest's vault directory and run `POST /nests/:id/stewards/sync`. Useful for version-controlled governance. Example:
+
+```yaml
+version: 1
+nest:
+  - email: governance-lead@acme.com
+    role: reviewer
+tags:
+  "#legal":
+    - email: legal@acme.com
+      role: reviewer
+  "#security":
+    - email: security-team@acme.com
+      role: reviewer
+```
+
+Sync replaces all stewards for that nest from the file. Prefer the UI for day-to-day adds; prefer the file for reproducible setups and code review.

package/dist/{chunk-2YPY2HGZ.js → chunk-2TPQTN4Y.js}

@@ -8,10 +8,11 @@ import {
   nestAllowsSelfApprove,
   nestName,
   primaryRole,
+  resolveNestAccess,
   resolveNestPermission,
   resolveTeamRolesForUser,
   sendEmailToRecipient
-} from "./chunk-QLXC6542.js";
+} from "./chunk-KIAAEHWL.js";
 import {
   ConflictError,
   ValidationError
@@ -20,7 +21,7 @@ import {
   config,
   getDb,
   isEmailish
-} from "./chunk-QWNXWRWO.js";
+} from "./chunk-LA3VTQ22.js";
 
 // src/governance/stewardship-service.ts
 import { v4 as uuid } from "uuid";
@@ -441,8 +442,8 @@ async function resolveUserRoles(nestId, userEmail, opts) {
 }
 async function canManageStewards(nestId, userId) {
   if (config.AUTH_MODE === "open") return true;
-  const perm = await resolveNestPermission(nestId, userId);
-  return perm === "owner" || perm === "admin";
+  const { rawPermission } = await resolveNestAccess(nestId, userId);
+  return rawPermission === "owner" || rawPermission === "admin";
 }
 async function canCreateInNest(nestId, userEmail) {
   if (config.AUTH_MODE === "open" || isSuperAdmin(userEmail)) return true;

package/dist/{chunk-MLQU4I5J.js → chunk-5EZOPA47.js}

@@ -4,19 +4,19 @@ import {
   resolveNestWideRoles,
   resolveStewardsForNode,
   stewardCoverageForUser
-} from "./chunk-2YPY2HGZ.js";
+} from "./chunk-2TPQTN4Y.js";
 import {
   grantCoversNode,
   listUserGrants,
   resolveNodeGrant
-} from "./chunk-UOMW7TT6.js";
+} from "./chunk-I3CSD6CK.js";
 import {
   createVersion,
   getApprovedVersion,
   getApprovedVersions,
   getCurrentVersion,
   setApprovedVersion
-} from "./chunk-5CVZMHHB.js";
+} from "./chunk-ZTT4U4NE.js";
 import {
   buildDocContext,
   buildTitleMap,
@@ -37,7 +37,7 @@ import {
   resolveNestPermission,
   sendEmailToRecipient,
   titleForNode
-} from "./chunk-QLXC6542.js";
+} from "./chunk-KIAAEHWL.js";
 import {
   ConflictError,
   NotFoundError,
@@ -46,7 +46,7 @@ import {
 import {
   config,
   getDb
-} from "./chunk-QWNXWRWO.js";
+} from "./chunk-LA3VTQ22.js";
 
 // src/governance/review-service.ts
 import { v4 as uuid2 } from "uuid";

package/dist/{chunk-UOMW7TT6.js → chunk-I3CSD6CK.js}

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

package/dist/{chunk-QLXC6542.js → chunk-KIAAEHWL.js}

@@ -8,7 +8,7 @@ import {
   config,
   getDb,
   isEmailish
-} from "./chunk-QWNXWRWO.js";
+} from "./chunk-LA3VTQ22.js";
 import {
   ANON_USER_ID
 } from "./chunk-YB3LKF7U.js";
@@ -1296,8 +1296,11 @@ async function listNotifications(userEmail, opts = {}) {
               CASE WHEN dr.target_type = 'document' THEN dr.node_id END,
               -- A mention names the document directly; there's no request row.
               CASE WHEN n.kind = 'mention' THEN n.subject_id END
-            ) AS node_id
+            ) AS node_id,
+            -- Name resolved here so the inbox never fetches the nest list for it.
+            COALESCE(ns.name, n.nest_id) AS nest_name
        FROM notifications n
+       LEFT JOIN nests ns ON ns.id = n.nest_id
        LEFT JOIN review_requests rr ON rr.id = n.subject_id
        LEFT JOIN deletion_requests dr ON dr.id = n.subject_id
       WHERE LOWER(n.user_email) = LOWER(?)${opts.unreadOnly ? " AND n.read_at IS NULL" : ""}
@@ -2488,6 +2491,9 @@ var FlatNestStorage = class extends NestStorage2 {
   }
 };
 
+// src/nodes/node-index.ts
+import { listSuggestions } from "@promptowl/contextnest-engine";
+
 // src/shared/node-id.ts
 function assertSafeNodeId(rawId) {
   let id = rawId;
@@ -2616,13 +2622,21 @@ async function ensureNodeIndex(nestId) {
   return run;
 }
 async function rebuildNodeIndex(nestId) {
-  const { engineCache: engineCache2 } = await import("./engine-QFF2IA3G.js");
-  const { documentsWithSuggestions } = await import("./external-edit-service-F7D3VSA2.js");
+  const { engineCache: engineCache2 } = await import("./engine-S3QBQ7LH.js");
+  const { documentsWithSuggestions } = await import("./external-edit-service-6FNFPOJJ.js");
   const { storage, dropDiscoveryCache } = await engineCache2.get(nestId);
   dropDiscoveryCache();
   const startedAt = writeGeneration.get(nestId) ?? 0;
   const documents = await storage.discoverDocuments({ includeRetired: true });
   const staged = await documentsWithSuggestions(nestId);
+  const stagedMetas = (await Promise.all(
+    [...staged].map(
+      (id) => listSuggestions(storage, id).catch((err) => {
+        console.error("[node-index] listSuggestions failed", nestId, id, err);
+        return [];
+      })
+    )
+  )).flat();
   const db = getDb();
   const insertSql = insertOrReplace(
     db,
@@ -2630,18 +2644,15 @@ async function rebuildNodeIndex(nestId) {
     ["nest_id", "node_id"],
     UPSERT_SET
   );
-  const stagedSql = insertOrIgnore(
-    db,
-    "INSERT INTO node_suggestions (nest_id, node_id) VALUES (?, ?)"
-  );
+  const stagedSql = insertOrIgnore(db, SUGGESTION_INSERT);
   await db.transaction(async (tx) => {
     await tx.run("DELETE FROM node_index WHERE nest_id = ?", [nestId]);
     for (const doc of documents) {
       await tx.run(insertSql, [nestId, ...rowValues(doc)]);
     }
     await tx.run("DELETE FROM node_suggestions WHERE nest_id = ?", [nestId]);
-    for (const id of staged) {
-      await tx.run(stagedSql, [nestId, id]);
+    for (const m of stagedMetas) {
+      await tx.run(stagedSql, suggestionValues(nestId, m));
     }
     if ((writeGeneration.get(nestId) ?? 0) !== startedAt) return;
     await tx.run(
@@ -2651,30 +2662,42 @@ async function rebuildNodeIndex(nestId) {
   });
   return documents.length;
 }
-async function setSuggestionFlag(nestId, nodeId, present) {
+var SUGGESTION_INSERT = "INSERT INTO node_suggestions (nest_id, node_id, suggestion_id, source, actor, detected_at, target_hash, proposed_hash, note) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)";
+var suggestionValues = (nestId, m) => [
+  nestId,
+  m.document_id,
+  m.suggestion_id,
+  m.source,
+  m.actor,
+  m.detected_at,
+  m.target_hash,
+  m.proposed_hash,
+  m.note ?? null
+];
+async function syncSuggestionRows(nestId, nodeId, metas) {
   try {
     const db = getDb();
-    if (!present) {
-      await db.run(
+    const insertSql = insertOrIgnore(db, SUGGESTION_INSERT);
+    await db.transaction(async (tx) => {
+      await tx.run(
         "DELETE FROM node_suggestions WHERE nest_id = ? AND node_id = ?",
         [nestId, nodeId]
       );
-      return;
-    }
-    await db.run(
-      insertOrIgnore(
-        db,
-        "INSERT INTO node_suggestions (nest_id, node_id) VALUES (?, ?)"
-      ),
-      [nestId, nodeId]
-    );
+      for (const m of metas) await tx.run(insertSql, suggestionValues(nestId, m));
+    });
   } catch (err) {
-    console.error("[node-index] suggestion flag failed", nestId, nodeId, err);
+    console.error("[node-index] suggestion rows failed", nestId, nodeId, err);
   }
 }
+async function listSuggestionRows(nestId) {
+  return await getDb().all(
+    "SELECT * FROM node_suggestions WHERE nest_id = ? ORDER BY detected_at DESC",
+    [nestId]
+  );
+}
 async function nodesWithSuggestions(nestId) {
   const rows = await getDb().all(
-    "SELECT node_id FROM node_suggestions WHERE nest_id = ?",
+    "SELECT DISTINCT node_id FROM node_suggestions WHERE nest_id = ?",
     [nestId]
   );
   return new Set(rows.map((r) => r.node_id));
@@ -2916,7 +2939,8 @@ export {
   markIndexStale,
   ensureNodeIndex,
   rebuildNodeIndex,
-  setSuggestionFlag,
+  syncSuggestionRows,
+  listSuggestionRows,
   nodesWithSuggestions,
   indexedNodeIds,
   readIndexedNodes,

package/dist/{chunk-QWNXWRWO.js → chunk-LA3VTQ22.js}

@@ -1757,6 +1757,30 @@ function runMigrations(db) {
       recordMigration("042_community_sites");
     })();
   }
+  if (!hasMigration("043_node_suggestion_details")) {
+    db.transaction(() => {
+      db.exec(`
+        DROP TABLE IF EXISTS node_suggestions;
+        CREATE TABLE node_suggestions (
+          nest_id TEXT NOT NULL REFERENCES nests(id) ON DELETE CASCADE,
+          node_id TEXT NOT NULL,
+          suggestion_id TEXT NOT NULL,
+          source TEXT NOT NULL,
+          actor TEXT NOT NULL,
+          detected_at TEXT NOT NULL,
+          target_hash TEXT NOT NULL,
+          proposed_hash TEXT NOT NULL,
+          note TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          PRIMARY KEY (nest_id, node_id, suggestion_id)
+        );
+        CREATE INDEX IF NOT EXISTS idx_node_suggestions_nest_detected
+          ON node_suggestions(nest_id, detected_at DESC);
+        UPDATE nests SET index_synced_at = NULL;
+      `);
+      recordMigration("043_node_suggestion_details");
+    })();
+  }
 }
 function fkViolationCounts(db) {
   const rows = db.pragma("foreign_key_check");
@@ -2031,7 +2055,7 @@ async function initDb() {
   if (config.DB_DRIVER === "postgres") {
     const { Pool } = await import("pg");
     const { PostgresAdapter } = await import("./adapter.postgres-6VZCMPQL.js");
-    const { runPostgresMigrations } = await import("./migrations.postgres-APCVSYUE.js");
+    const { runPostgresMigrations } = await import("./migrations.postgres-AIQ7WSU7.js");
     const pool = new Pool(buildPgConfig());
     adapter = new PostgresAdapter(pool);
     await runPostgresMigrations(adapter);