neotoma 0.26.0 → 0.27.0

package/README.md

@@ -61,13 +61,13 @@ graph LR
 
 ## What you can do with it
 
-Neotoma v0.26.0 exposes 67 MCP tools and 112 REST paths in its OpenAPI spec. They cover largely the same capabilities, but the MCP server, the REST API, and the CLI are separate implementations, and some checks and attribution differ between them (see Known limitations). The capability surface includes:
+Neotoma v0.27.0 exposes 67 MCP tools and 112 REST paths in its OpenAPI spec. They cover largely the same capabilities, but the MCP server, the REST API, and the CLI are separate implementations, and some checks and attribution differ between them (see Known limitations). The capability surface includes:
 
 **Ingest and store.** Store structured records or raw files in one call. File ingestion extracts text from PDF (with a first-page image fallback), CSV (with adaptive chunking for large files), Parquet, JSON, and plain text; images and audio are stored as raw sources. A committed, keyed structured store started on v0.26.0 that stops partway finishes its missing observations on a same-key retry; a store carrying an interpretation returns `ERR_STORE_WRITE_INCOMPLETE`, and keys left over from earlier versions behave differently over MCP and HTTP (see Known limitations). See Known limitations.
 
 **Resolve, retrieve, and search.** Look up entities by identifier (name, email, and similar), resolve identity from multiple signals with confidence scoring, list observations, retrieve a field's provenance chain, traverse the relationship graph N hops, and pull a full graph neighborhood. When an embedding key is configured, semantic vector search runs over entity snapshots (stored locally in sqlite-vec); keyword filtering works without it.
 
-**Correct and evolve.** Submit corrections as high-priority observations, never edits; the earlier observation stays readable. Schemas are inferred from your data, recommended from recurring unknown fields, and can be auto-enhanced or updated incrementally with versioning. New entity types work without any code change.
+**Correct and evolve.** Submit corrections as observations marked as corrections, never edits: a correction wins in the snapshot until a later correction for the same field replaces it, on array fields too, and the earlier observation stays readable. Schemas are inferred from your data, recommended from recurring unknown fields, and can be auto-enhanced or updated incrementally with versioning. New entity types work without any code change.
 
 **Relate and sequence.** Create typed relationships (for example `PART_OF`, `DEPENDS_ON`, `REFERS_TO`, `DUPLICATE_OF`), query timeline events across types and date ranges, and read an entity's observation history in a deterministic order.
 
@@ -111,7 +111,7 @@ neotoma init
 neotoma setup --tool claude-code
 ```
 
-In v0.26.0, `neotoma setup --tool claude-code` writes the MCP entries and more:
+In v0.27.0, `neotoma setup --tool claude-code` writes the MCP entries and more:
 
 - Two MCP entries in the project's `.mcp.json`: `neotoma-dev` (development profile, `neotoma.db`) and `neotoma` (production profile, `neotoma.prod.db`). They use separate databases, so an agent on one entry does not see what an agent on the other stored.
 - CLI instruction files for Claude Code, Cursor, and Codex in the project: `.claude/rules/neotoma_cli.mdc`, `.cursor/rules/neotoma_cli.mdc`, and `.codex/neotoma_cli.md`.

package/dist/actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../src/actions.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,wBAAwB,EAE9B,MAAM,+BAA+B,CAAC;AACvC,OAAO,OAAO,MAAM,SAAS,CAAC;AA2C9B,OAAO,EAIL,KAAK,wBAAwB,EAC7B,KAAK,wBAAwB,EAC9B,MAAM,mCAAmC,CAAC;AAS3C,OAAO,EAAqB,KAAK,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAgBpF,OAAO,EAGL,KAAK,aAAa,EAGnB,MAAM,4BAA4B,CAAC;AAoDpC,OAAO,EAUL,KAAK,sBAAsB,EAC5B,MAAM,4BAA4B,CAAC;AAkDpC,OAAO,EAGL,oBAAoB,EACrB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AA2ElE,OAAO,EAAE,cAAc,EAA0B,MAAM,uBAAuB,CAAC;AAqB/E,6FAA6F;AAC7F,wBAAgB,qBAAqB,IAAI,sBAAsB,GAAG,IAAI,CAErE;AAED,eAAO,MAAM,GAAG,6CAAY,CAAC;AA8Y7B,sGAAsG;AACtG,wBAAgB,oBAAoB,CAAC,GAAG,GAAE,MAAiC,wDAkB1E;AA+ZD,kFAAkF;AAClF,eAAO,MAAM,4BAA4B,QAAS,CAAC;AAEnD;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAMtE;AAoBD,uFAAuF;AACvF,eAAO,MAAM,wBAAwB,OAAQ,CAAC;AAE9C;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAMlE;AAID;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,OAAO,CAAC,OAAO,EACpB,GAAG,EAAE,OAAO,CAAC,QAAQ,EACrB,OAAO,CAAC,EAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE;QAAE,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;KAAE,CAAA;CAAE,GAC7F,IAAI,CA4IN;AAuBD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,OAAO,CAmC1F;AAoGD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,CAAC,OAAO,GAAG,OAAO,CA6D5D;AAcD,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAEjE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,8BAA8B,CAAC,GAAG,EAAE,OAAO,CAAC,OAAO,GAAG,OAAO,CAG5E;AAwBD;+EAC+E;AAC/E,eAAO,MAAM,gBAAgB,sBAA6B,CAAC;AAE3D;;;;;;;GAOG;AACH,eAAO,MAAM,+BAA+B,QAAc,CAAC;AAE3D;;;gEAGgE;AAChE,eAAO,MAAM,2BAA2B,QAAgB,CAAC;AAEzD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAKzE;AA4OD;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,OAAO,CAAC,OAAO,EACpB,GAAG,EAAE,OAAO,CAAC,QAAQ,EACrB,KAAK,CAAC,EAAE,MAAM,GACb,MAAM,CAgBR;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,OAAO,CAAC,OAAO,GAAG,MAAM,GAAG,SAAS,CAKhF;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,OAAO,CAAC,OAAO,GAAG,aAAa,GAAG,SAAS,CAGzF;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,IAAI,MAAM,CA2BhD;AA80DD,KAAK,aAAa,GAAG;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,KAAK,cAAc,GAAG;IACpB,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,aAAa,CAAC;IACvB,aAAa,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IACrC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,KAAK,cAAc,GAAG,aAAa,GAAG,cAAc,CAAC;AA2CrD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,6BAA6B,aAAqD,CAAC;AAEhG,4GAA4G;AAC5G,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,QAAQ,GAAG,MAAM,CAAC,GAAG,OAAO,CA0BjG;AAED;;;;;;;;GAQG;AACH,wBAAgB,kCAAkC,CAChD,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,QAAQ,GAAG,MAAM,CAAC,GAC5C,OAAO,CAST;AAED,oHAAoH;AACpH,wBAAgB,6BAA6B,CAC3C,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,QAAQ,GAAG,MAAM,CAAC,GAC5C,OAAO,CAWT;AAED,mGAAmG;AACnG,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,OAAO,CAAC,OAAO,GAAG,MAAM,CAanE;AAoBD;;;;;;;;;;GAUG;AACH,wBAAgB,gCAAgC,CAC9C,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,QAAQ,GAAG,MAAM,CAAC,GAC5C,OAAO,CAIT;AAiHD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,OAAO,CAAC,OAAO,EACpB,SAAS,EAAE,cAAc,GACxB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAoCxB;AAkkBD;;;;;;;;;;;;;;;;GAgBG;AAIH,wBAAsB,sBAAsB,CAC1C,GAAG,EAAE,OAAO,CAAC,OAAO,EACpB,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,MAAM,CAAC,CA4CjB;AAwyFD;;;;;;;;GAQG;AACH,wBAAsB,qBAAqB,CAAC,MAAM,EAAE,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA8jC3D,MAAM;eACZ,MAAM;2BACM,MAAM;;;;;;cAtBnB,MAAM;iBACH,MAAM;2BACI,MAAM;qBACZ,MAAM;mBACR,MAAM;kBAIP,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;cAnC3B,MAAM;gBACJ,MAAM;2BACK,MAAM;qBACZ,MAAM;mBACR,MAAM;wBACD,MAAM;uBACP,MAAM;;;;;;mBAjUV,MAAM;qBACJ,MAAM;wBACH,MAAM,GAAG,IAAI;2BACV,MAAM;;wBAET,MAAM;uBACP,MAAM,EAAE;wBACP,MAAM;uBACP,MAAM;;kBAtaX,MAAM;oBACJ,MAAM;yBACD,MAAM;4BACH,MAAM;2BACP,MAAM;;;kBAQf,MAAM;yBACC,MAAM;iCACE,MAAM;sCACD,MAAM;;+BA0Zb,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;;;;;;;;;GAvtBxD;AA28CD,wBAAsB,uBAAuB,CAAC,MAAM,EAAE;IACpD,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,QAAQ,GAAG,WAAW,CAAC;IACrC;;;;;;;;OAQG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoGA;AAiwID;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,MAAM,CAEhF;AAKD,OAAO,EAAE,cAAc,EAAE,CAAC;AAE1B;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,GACnB,OAAO,CAAC;IAAE,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAgD1E;AAGD,wBAAsB,eAAe;;;eA8YpC;AAsBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAiBtE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gCAAgC,IAAI,IAAI,CAqCvD"}
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../src/actions.ts"],"names":[],"mappings":"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"}

package/dist/actions.js

@@ -1,4 +1,4 @@
-import { preflightStructuredStoreAdmission, } from "./services/store_admission.js";
+import { assertCurrentAgentMayStoreEntityTypes, assertStoreEntityTypesNamed, InvalidEntityTypeError, preflightStructuredStoreAdmission, } from "./services/store_admission.js";
 import express from "express";
 import cookieParser from "cookie-parser";
 import cors from "cors";
@@ -38,6 +38,7 @@ import { CursorError } from "./services/entity_cursor.js";
 import { assertNoShadowedRoutes } from "./services/route_shadowing.js";
 import { StorePolicyDeniedError, StorePolicyUnavailableError } from "./services/instance_policy.js";
 import { AgentCapabilityError, contextFromAgentIdentity, enforceAgentCapability, } from "./services/agent_capabilities.js";
+import { ISSUE_THREAD_ENTITY_TYPES, assertCurrentAgentMay, assertCurrentAgentMayLink, assertCurrentAgentMayOnEntities, assetEntityTypeForMimeType, } from "./services/mutation_capability.js";
 import { AccessPolicyError } from "./services/access_policy.js";
 import { hashGuestAccessToken } from "./services/guest_access_token.js";
 import { subscriptionWithinGuestScope } from "./services/subscriptions/guest_scope.js";
@@ -73,6 +74,7 @@ import { getSandboxTermsResponse } from "./services/sandbox/terms.js";
 import { resolveSandboxReportTransport } from "./services/sandbox/transport.js";
 import { getDb } from "./repositories/db/connection.js";
 import { getMcpAuthToken } from "./crypto/mcp_auth_token.js";
+import { announceBearerHandoverStatus, matchConfiguredBearer, recordPreviousBearerUse, } from "./services/bearer_slots.js";
 import { isOauthKeyCredentialValid, normalizeOauthNextPath, OAuthKeySessionStore, } from "./services/oauth_key_gate.js";
 import { buildGoogleAuthorizeUrl, createGoogleSigninNonce, consumeGoogleSigninNonce, exchangeGoogleAuthorizationCode, getSharedGraphUserId, GoogleIdTokenError, isGoogleSigninEnabled, verifyGoogleIdToken, } from "./services/google_oidc.js";
 import { AnalyzeSchemaCandidatesRequestSchema, AuditUndeclaredFragmentsRequestSchema, CorrectEntityRequestSchema, PatchArrayItemRequestSchema, CreateInterpretationRequestSchema, CreateRelationshipsRequestSchema, CreateRelationshipRequestSchema, DeleteEntityRequestSchema, DeleteRelationshipRequestSchema, IssuesBulkEntityIdsRequestSchema, IssuesAddMessageRequestSchema, IssuesGetStatusRequestSchema, IssuesSubmitRequestSchema, IssuesSyncRequestSchema, EntitiesQueryRequestSchema, EntitySnapshotRequestSchema, FieldProvenanceRequestSchema, GetSchemaRecommendationsRequestSchema, ListObservationsRequestSchema, ListRelationshipsRequestSchema, MergeEntitiesRequestSchema, SplitEntityRequestSchema, ObservationsQueryRequestSchema, RegisterSchemaRequestSchema, RelationshipSnapshotRequestSchema, RestoreEntityRequestSchema, RestoreRelationshipRequestSchema, RetrieveEntityByIdentifierSchema, RetrieveGraphNeighborhoodSchema, RetrieveRelatedEntitiesSchema, RELATIONSHIP_ENTITY_ID_FORMAT_HINT, RELATIONSHIP_ENTITY_ID_FORMAT_ISSUE_CODE, ObservationSourceSchema, StoreRequestSchema, UpdateSchemaIncrementalRequestSchema, } from "./shared/action_schemas.js";
@@ -1805,7 +1807,20 @@ app.all("/mcp", async (req, res) => {
             }
             if (authHeader?.startsWith("Bearer ") && process.env.NEOTOMA_BEARER_TOKEN) {
                 const token = authHeader.slice(7).trim();
-                if (safeCompareTokens(token, process.env.NEOTOMA_BEARER_TOKEN)) {
+                // Either configured slot (primary, or the retiring bearer while its
+                // handover window is open) takes the SAME branch: same principal,
+                // same grants. See src/services/bearer_slots.ts.
+                const slot = matchConfiguredBearer(token);
+                if (slot) {
+                    if (slot === "previous") {
+                        recordPreviousBearerUse({
+                            surface: "mcp",
+                            method: req.method,
+                            path: req.path,
+                            userAgent: req.headers["user-agent"],
+                            clientName: req.headers["x-client-name"],
+                        });
+                    }
                     setGateConnectionIdHeader(req, "dev-local");
                     connectionIdHeader = "dev-local";
                     bearerValidated = true;
@@ -3825,10 +3840,22 @@ app.use(async (req, res, next) => {
         }
         if (headerAuth.startsWith("Bearer ") && process.env.NEOTOMA_BEARER_TOKEN) {
             const token = headerAuth.slice(7).trim();
-            if (safeCompareTokens(token, process.env.NEOTOMA_BEARER_TOKEN)) {
+            // Either configured slot takes the SAME branch: same principal, same
+            // grants. See src/services/bearer_slots.ts.
+            const slot = matchConfiguredBearer(token);
+            if (slot) {
+                if (slot === "previous") {
+                    recordPreviousBearerUse({
+                        surface: "rest",
+                        method: req.method,
+                        path: req.path,
+                        userAgent: req.headers["user-agent"],
+                        clientName: req.headers["x-client-name"],
+                    });
+                }
                 const devUser = await ensureLocalDevUser();
                 stampUserPrincipal(req, devUser.id);
-                logger.info(`[Auth] ${req.method} ${req.path} auth_method=bearer_env user_id=${devUser.id}`);
+                logger.info(`[Auth] ${req.method} ${req.path} auth_method=${slot === "previous" ? "bearer_env_previous" : "bearer_env"} user_id=${devUser.id}`);
                 return next();
             }
         }
@@ -4594,26 +4621,10 @@ app.get("/entities/:id/html", async (req, res) => {
         if (etag)
             res.setHeader("ETag", etag);
         res.setHeader("Content-Type", "text/html; charset=utf-8");
-        // SECURITY (Phase 2, stored XSS in publish_rendered_page): html_body is
-        // author-supplied and served verbatim, and the GLOBAL CSP allows
-        // 'unsafe-inline' scripts — so an injected <script> in a rendered page would
-        // execute in this origin (a page minted with a guest access_token is viewable
-        // unauthenticated). Rendered pages are static CONTENT, never applications:
-        // they never need to run script. Override the global policy for THIS response
-        // with a strict, self-contained CSP that blocks all script execution (inline
-        // and external) and sandboxes the document, neutralizing stored XSS regardless
-        // of html_body contents. Inline <style> from the template is still allowed.
-        res.setHeader("Content-Security-Policy", [
-            "default-src 'none'",
-            "script-src 'none'",
-            "style-src 'unsafe-inline'",
-            "img-src 'self' data:",
-            "font-src 'self' data:",
-            "base-uri 'none'",
-            "form-action 'none'",
-            "frame-ancestors 'self'",
-            "sandbox allow-same-origin",
-        ].join("; "));
+        // Author scripts stay blocked. Opted-in copy blocks permit only the fixed
+        // renderer-owned helper, confined to an opaque-origin sandbox.
+        const { renderedPageContentSecurityPolicy } = await import("./services/rendered_page/copy_controls.js");
+        res.setHeader("Content-Security-Policy", renderedPageContentSecurityPolicy(htmlBody));
         res.setHeader("X-Content-Type-Options", "nosniff");
         return res.send(html);
     }
@@ -4671,6 +4682,10 @@ app.post("/entities/:id/batch_correct", async (req, res) => {
         if (error instanceof Error && error.message.includes("Not authenticated")) {
             return sendError(res, 401, "AUTH_REQUIRED", error.message);
         }
+        // Capability denial: same 403 `capability_denied` envelope as /correct.
+        if (error instanceof AgentCapabilityError) {
+            return handleApiError(req, res, error, "Failed to apply batch correction", "DB_QUERY_FAILED", "AgentCapabilityRejection:entity_batch_correct");
+        }
         logError("APIError:entity_batch_correct", req, error);
         const message = error instanceof Error ? error.message : "Failed to apply batch correction";
         return sendError(res, 500, "DB_QUERY_FAILED", message);
@@ -6097,6 +6112,10 @@ app.post("/interpretations/create", async (req, res) => {
     }
     try {
         const userId = await getAuthenticatedUserId(req, parsed.data.user_id);
+        // Same per-type `store` capability scope `/store` applies, before any
+        // source lookup or write. No-op without an agent identity.
+        const { assertInterpretationStoreCapability, runInterpretation } = await import("./services/interpretation.js");
+        await assertInterpretationStoreCapability(userId, parsed.data.entities);
         const { data: source, error: sourceError } = await db
             .from("sources")
             .select("id")
@@ -6108,7 +6127,6 @@ app.post("/interpretations/create", async (req, res) => {
         if (!source) {
             return sendError(res, 404, "SOURCE_NOT_FOUND", "Source not found for authenticated user");
         }
-        const { runInterpretation } = await import("./services/interpretation.js");
         const interpretationResult = await runInterpretation({
             userId,
             sourceId: parsed.data.source_id,
@@ -6190,6 +6208,14 @@ app.post("/interpretations/create", async (req, res) => {
         });
     }
     catch (error) {
+        // Capability denial: same 403 `capability_denied` envelope as `/store`.
+        if (error instanceof AgentCapabilityError) {
+            return handleApiError(req, res, error, "Failed to create interpretation", "INTERPRETATION_CREATE_FAILED", "AgentCapabilityRejection:interpretations_create");
+        }
+        if (error instanceof InvalidEntityTypeError) {
+            logWarn("InvalidEntityTypeError:interpretations_create", req, { code: error.code });
+            return sendError(res, 400, error.code, error.message, { hint: error.hint });
+        }
         logError("APIError:interpretations_create", req, error);
         const message = error instanceof Error ? error.message : "Failed to create interpretation";
         return sendError(res, 500, "INTERPRETATION_CREATE_FAILED", message);
@@ -6302,6 +6328,9 @@ app.post("/observations/create", async (req, res) => {
                 .status(403)
                 .json(buildErrorEnvelope("FORBIDDEN", "user_id does not match authenticated user."));
         }
+        // Same per-type `store` capability scope `/store` applies, before the
+        // entity is resolved or created. No-op without an agent identity.
+        assertCurrentAgentMayStoreEntityTypes([entity_type]);
         const { resolveEntity } = await import("./services/entity_resolution.js");
         const { createObservation } = await import("./services/observation_storage.js");
         const { getSnapshot, recomputeSnapshot } = await import("./services/snapshot_computation.js");
@@ -6333,6 +6362,10 @@ app.post("/observations/create", async (req, res) => {
         });
     }
     catch (error) {
+        // Capability denial: same 403 `capability_denied` envelope as `/store`.
+        if (error instanceof AgentCapabilityError) {
+            return handleApiError(req, res, error, "Failed to create observation", "DB_QUERY_FAILED", "AgentCapabilityRejection:observations_create");
+        }
         logError("APIError:observations_create", req, error);
         const message = error instanceof Error ? error.message : "Failed to create observation";
         return res.status(500).json(buildErrorEnvelope("DB_QUERY_FAILED", message));
@@ -7619,6 +7652,9 @@ export async function storeUnstructuredForApi(params) {
             observations_created: 0,
         };
     }
+    // Agent grants: an upload is recorded under its asset type (the type the
+    // MCP leg writes for the same bytes). Checked before the source is stored.
+    assertCurrentAgentMay("store", [assetEntityTypeForMimeType(mimeType)], { guestCapable: true });
     if (storageMode === "reference") {
         if (!filePath) {
             throw new Error("filePath is required for reference storage mode");
@@ -7693,9 +7729,24 @@ async function handleStorePost(req, res) {
         const { assertConditionalStoreRequest } = await import("./services/store_condition_request.js");
         assertConditionalStoreRequest(parsed.data);
         const hasEntities = Boolean(parsed.data.entities?.length);
+        // Every entity must name its type as a non-empty string, for every caller
+        // kind, before either leg of the request writes anything.
+        if (hasEntities)
+            assertStoreEntityTypesNamed(parsed.data.entities);
         const hasFileContent = Boolean(parsed.data.file_content && parsed.data.mime_type);
         const hasFilePath = Boolean(parsed.data.file_path);
         const hasUnstructured = hasFileContent || hasFilePath;
+        // Agent grants on the file leg, before either leg writes, so a combined
+        // entities-and-file call refused on the file writes no entities either.
+        if (hasUnstructured && parsed.data.commit !== false) {
+            const uploadMime = parsed.data.mime_type ||
+                (parsed.data.file_path
+                    ? getMimeTypeFromExtension(path.extname(parsed.data.file_path).toLowerCase())
+                    : undefined);
+            assertCurrentAgentMay("store", [assetEntityTypeForMimeType(uploadMime)], {
+                guestCapable: true,
+            });
+        }
         if (hasEntities && hasUnstructured && parsed.data.commit !== false) {
             const { claimCombinedStoreKeys } = await import("./services/store_combined_admission.js");
             await claimCombinedStoreKeys({
@@ -7863,6 +7914,10 @@ async function handleStorePost(req, res) {
             logWarn("AgentGrantPinConflict:store", req, { code: error.code });
             return sendError(res, 409, error.code, error.message, { field: error.field });
         }
+        if (error instanceof InvalidEntityTypeError) {
+            logWarn("InvalidEntityTypeError:store", req, { code: error.code });
+            return sendError(res, 400, error.code, error.message, { hint: error.hint });
+        }
         if (errCode === "ERR_FORBIDDEN_ENTITY_TYPE" || errCode === "ERR_PLURAL_ENTITY_TYPE") {
             const message = error instanceof Error ? error.message : String(error);
             logWarn("EntityTypeGuardError:store", req, { code: errCode, message });
@@ -8083,6 +8138,10 @@ app.post("/sync/webhook", express.raw({ type: "application/json", limit: "2mb" }
         if (msg === "INVALID_JSON" || msg.startsWith("VALIDATION_ERROR")) {
             return sendError(res, 400, "VALIDATION_ERROR", msg);
         }
+        if (msg.startsWith("REMOTE_ENTITY_TYPE_REFUSED")) {
+            const { SYNC_ENTITY_TYPE_REFUSED_ERROR_CODE } = await import("./services/sync/remote_snapshot_admission.js");
+            return sendError(res, 403, SYNC_ENTITY_TYPE_REFUSED_ERROR_CODE, msg);
+        }
         logError("APIError:sync_webhook", req, err);
         return sendError(res, 500, "SYNC_WEBHOOK_FAILED", msg);
     }
@@ -8159,6 +8218,9 @@ app.post("/peers", express.json(), async (req, res) => {
         return res.status(201).json(out);
     }
     catch (error) {
+        if (error instanceof AgentCapabilityError) {
+            return handleApiError(req, res, error, "Failed to add peer");
+        }
         logError("APIError:peers_add", req, error);
         const message = error instanceof Error ? error.message : "Failed to add peer";
         if (message.includes("Maximum peers")) {
@@ -8167,8 +8229,11 @@ app.post("/peers", express.json(), async (req, res) => {
         return sendError(res, 500, "PEER_ADD_FAILED", message);
     }
 });
-// POST /peers/resolve_sync_conflict — stub (use `correct` today). Registered
-// before `/peers/:peer_id` so `resolve_sync_conflict` is not captured as a peer_id.
+// POST /peers/resolve_sync_conflict — resolve a replication conflict. `prefer_remote`
+// and `manual` write correction-tier values, so they run the same `correct` capability
+// gate as `/correct`; `prefer_remote` applies the differing fields as one correction
+// transaction and reports applied and withheld fields. Registered before
+// `/peers/:peer_id` so `resolve_sync_conflict` is not captured as a peer_id.
 app.post("/peers/resolve_sync_conflict", express.json(), async (req, res) => {
     const schema = z.object({
         entity_id: z.string().min(1),
@@ -8199,6 +8264,14 @@ app.post("/peers/resolve_sync_conflict", express.json(), async (req, res) => {
         return res.json(result);
     }
     catch (error) {
+        // A capability or protected-type refusal is the caller's authorization,
+        // not a server fault: 403 with the envelope `/correct` returns.
+        if (error instanceof AgentCapabilityError) {
+            logWarn("AgentCapabilityRejection:peers_resolve", req, error.toErrorEnvelope());
+            return res
+                .status(403)
+                .json(buildErrorEnvelope(error.code, error.message, error.toErrorEnvelope()));
+        }
         logError("APIError:peers_resolve", req, error);
         const message = error instanceof Error ? error.message : "resolve failed";
         return sendError(res, 500, "PEER_RESOLVE_FAILED", message);
@@ -8225,11 +8298,16 @@ app.get("/peers/:peer_id", async (req, res) => {
 app.delete("/peers/:peer_id", async (req, res) => {
     try {
         const userId = await getAuthenticatedUserId(req);
+        // Agent grants: removing a peer corrects its peer_config.
+        assertCurrentAgentMay("correct", ["peer_config"]);
         const { removePeerForUser } = await import("./services/sync/peer_ops.js");
         await removePeerForUser({ userId, peer_id: req.params.peer_id });
         return res.json({ success: true });
     }
     catch (error) {
+        if (error instanceof AgentCapabilityError) {
+            return handleApiError(req, res, error, "Failed to remove peer");
+        }
         logError("APIError:peers_remove", req, error);
         const message = error instanceof Error ? error.message : "Failed to remove peer";
         if (message.includes("not found")) {
@@ -8245,11 +8323,17 @@ app.post("/peers/:peer_id/sync", express.json(), async (req, res) => {
         const bodySchema = z.object({ limit: z.number().int().positive().max(500).optional() });
         const bodyParsed = bodySchema.safeParse(req.body ?? {});
         const limit = bodyParsed.success ? bodyParsed.data.limit : undefined;
+        // Agent grants: a sync run sends local data to the peer and advances the
+        // peer_config watermark; pulled rows are still checked per type by store.
+        assertCurrentAgentMay("correct", ["peer_config"]);
         const { syncPeerFull } = await import("./services/sync/full_sync.js");
         const result = await syncPeerFull({ userId, peer_id: req.params.peer_id, limit });
         return res.json(result);
     }
     catch (error) {
+        if (error instanceof AgentCapabilityError) {
+            return handleApiError(req, res, error, "sync_peer failed");
+        }
         logError("APIError:peers_sync", req, error);
         const message = error instanceof Error ? error.message : "sync_peer failed";
         return sendError(res, 500, "PEER_SYNC_FAILED", message);
@@ -8350,6 +8434,8 @@ app.post("/entities/merge", async (req, res) => {
         if (providedUserId && providedUserId !== authenticatedUserId) {
             return sendError(res, 403, "FORBIDDEN", "user_id does not match authenticated user.");
         }
+        // Agent grants: `merge` on both entities' stored types, before any write.
+        await assertCurrentAgentMayOnEntities("merge", user_id, [from_entity_id, to_entity_id]);
         const { mergeEntities } = await import("./services/entity_merge.js");
         const result = await mergeEntities({
             fromEntityId: from_entity_id,
@@ -8361,6 +8447,9 @@ app.post("/entities/merge", async (req, res) => {
         return res.json(result);
     }
     catch (error) {
+        if (error instanceof AgentCapabilityError) {
+            return handleApiError(req, res, error, "Failed to merge entities");
+        }
         const { EntityNotFoundError, EntityAlreadyMergedError } = await import("./services/entity_merge.js");
         if (error instanceof EntityNotFoundError) {
             return sendError(res, 404, "RESOURCE_NOT_FOUND", error.message);
@@ -8390,6 +8479,9 @@ app.post("/entities/split", async (req, res) => {
             return sendError(res, 403, "FORBIDDEN", "user_id does not match authenticated user.");
         }
         const userId = providedUserId || authenticatedUserId;
+        // Agent grants: `split` on the source's stored type, the new entity's
+        // type and, when the split targets an existing entity, its stored type.
+        await assertCurrentAgentMayOnEntities("split", userId, [parsed.data.source_entity_id, parsed.data.new_entity.target_entity_id ?? ""], [parsed.data.new_entity.entity_type]);
         const { splitEntity } = await import("./services/entity_split.js");
         const result = await splitEntity({
             sourceEntityId: parsed.data.source_entity_id,
@@ -8407,6 +8499,9 @@ app.post("/entities/split", async (req, res) => {
         return res.json(result);
     }
     catch (error) {
+        if (error instanceof AgentCapabilityError) {
+            return handleApiError(req, res, error, "Failed to split entity");
+        }
         const { EntityNotFoundError, EntityAlreadyMergedError, SplitPredicateMatchedNothingError, SplitPredicateMatchedAllError, IdempotencyMismatchError, } = await import("./services/entity_split.js");
         if (error instanceof EntityNotFoundError) {
             return sendError(res, 404, "RESOURCE_NOT_FOUND", error.message);
@@ -9177,6 +9272,9 @@ app.post("/delete_entity", async (req, res) => {
     try {
         const userId = await getAuthenticatedUserId(req, parsed.data.user_id);
         const { entity_id, entity_type, reason } = parsed.data;
+        // Agent grants: `delete` on the stored type (and the type the request
+        // names), before the deletion observation is written.
+        await assertCurrentAgentMayOnEntities("delete", userId, [entity_id], [entity_type]);
         const { softDeleteEntity } = await import("./services/deletion.js");
         const result = await softDeleteEntity(entity_id, entity_type, userId, reason);
         if (!result.success) {
@@ -9199,6 +9297,8 @@ app.post("/issues/bulk_close", async (req, res) => {
     }
     try {
         const userId = await getAuthenticatedUserId(req, parsed.data.user_id);
+        // Agent grants: closing corrects the issue (and its GitHub state).
+        await assertCurrentAgentMayOnEntities("correct", userId, parsed.data.entity_ids, ["issue"]);
         const { bulkCloseIssues } = await import("./services/issues/inspector_bulk.js");
         const { results } = await bulkCloseIssues(userId, parsed.data.entity_ids);
         logDebug("Success:issues_bulk_close", req, { count: results.length });
@@ -9217,6 +9317,8 @@ app.post("/issues/bulk_remove", async (req, res) => {
     }
     try {
         const userId = await getAuthenticatedUserId(req, parsed.data.user_id);
+        // Agent grants: removal closes and soft-deletes the issue.
+        await assertCurrentAgentMayOnEntities("delete", userId, parsed.data.entity_ids, ["issue"]);
         const { bulkRemoveIssues } = await import("./services/issues/inspector_bulk.js");
         const { results } = await bulkRemoveIssues(userId, parsed.data.entity_ids);
         logDebug("Success:issues_bulk_remove", req, { count: results.length });
@@ -9239,6 +9341,15 @@ const handleIssuesAddMessageHttp = async (req, res) => {
         const userId = principal.kind === "guest"
             ? (await resolveGuestScopedEntityAccess(principal, parsed.data.entity_id?.trim() || "", "issue")).userId
             : await getAuthenticatedUserId(req, parsed.data.user_id);
+        // Agent grants on the owner path: a thread message is an issue-thread
+        // write (and a GitHub comment). The in-process operations layer below does
+        // not carry the caller's grant, so the check runs here, before anything is
+        // written. The guest path stays scoped by its guest access token.
+        if (principal.kind !== "guest") {
+            assertCurrentAgentMay("store", ISSUE_THREAD_ENTITY_TYPES, { guestCapable: true });
+            // Edges from the issue to entities the caller names.
+            await assertCurrentAgentMayLink(userId, "issue", "REFERS_TO", parsed.data.entity_ids_to_link ?? [], { guestCapable: true });
+        }
         const { createOperations } = await import("./core/operations.js");
         const { NeotomaServer } = await import("./server.js");
         const { addIssueMessage, appendGuestIssueMessage } = await import("./services/issues/issue_operations.js");
@@ -9311,6 +9422,16 @@ const handleIssuesSubmitHttp = async (req, res) => {
                 ? ((await resolveGuestUserId(req, principal)) ??
                     (await getAuthenticatedUserId(req, parsed.data.user_id)))
                 : await getAuthenticatedUserId(req, parsed.data.user_id);
+        // Agent grants on the owner path: it writes an issue thread under the
+        // owner and may open a GitHub issue. The in-process operations layer below
+        // does not carry the caller's grant, so the check runs here, before
+        // anything is written. The guest path stays under access policy, as for
+        // any guest.
+        if (!(principal.kind === "guest" || guestSubmitPayload)) {
+            assertCurrentAgentMay("store", ISSUE_THREAD_ENTITY_TYPES, { guestCapable: true });
+            // Edges from the new issue to entities the caller names.
+            await assertCurrentAgentMayLink(userId, "issue", "REFERS_TO", [...(parsed.data.entity_ids_to_link ?? []), parsed.data.conversation_turn_id ?? ""], { guestCapable: true });
+        }
         const { createOperations } = await import("./core/operations.js");
         const { NeotomaServer } = await import("./server.js");
         const { submitIssue, submitGuestIssue } = await import("./services/issues/issue_operations.js");
@@ -9434,6 +9555,10 @@ const handleIssuesSyncHttp = async (req, res) => {
     }
     try {
         const userId = await getAuthenticatedUserId(req, parsed.data.user_id);
+        // Agent grants: a sync stores new issue threads, corrects existing ones
+        // and can push local issues to GitHub.
+        assertCurrentAgentMay("store", ISSUE_THREAD_ENTITY_TYPES);
+        assertCurrentAgentMay("correct", ISSUE_THREAD_ENTITY_TYPES);
         const { createOperations } = await import("./core/operations.js");
         const { NeotomaServer } = await import("./server.js");
         const { syncIssuesFromGitHub } = await import("./services/issues/sync_issues_from_github.js");
@@ -9480,6 +9605,9 @@ app.post("/restore_entity", async (req, res) => {
     try {
         const userId = await getAuthenticatedUserId(req, parsed.data.user_id);
         const { entity_id, entity_type, reason } = parsed.data;
+        // Agent grants: `restore` on the stored type (and the type the request
+        // names), before the restoration observation is written.
+        await assertCurrentAgentMayOnEntities("restore", userId, [entity_id], [entity_type]);
         const { restoreEntity } = await import("./services/deletion.js");
         const result = await restoreEntity(entity_id, entity_type, userId, reason);
         if (!result.success) {
@@ -9750,6 +9878,8 @@ app.post("/update_schema_incremental", async (req, res) => {
         // can defer to whichever scope its own read resolved instead of being
         // told "global" by a default this route manufactured.
         user_specific, activate = true, migrate_existing = false, force = false, } = parsed.data;
+        // Agent grants: `register_schema` on the entity type, before any write.
+        assertCurrentAgentMay("register_schema", [entity_type]);
         const { schemaRegistry, loadCodeDefinedSchemaEntry } = await import("./services/schema_registry.js");
         // #2454 / #2374 REST parity with the MCP handler: the existence guard
         // resolves the SAME row `updateSchemaIncremental` will read —
@@ -10032,6 +10162,8 @@ app.post("/register_schema", async (req, res) => {
     try {
         const userId = await getAuthenticatedUserId(req, parsed.data.user_id);
         const { entity_type, schema_definition, reducer_config, schema_version = "1.0", user_specific = false, activate = false, force = false, } = parsed.data;
+        // Agent grants: `register_schema` on the entity type, before any write.
+        assertCurrentAgentMay("register_schema", [entity_type]);
         const { schemaRegistry } = await import("./services/schema_registry.js");
         // R2 back-compat: existing HTTP/CLI callers may register schemas
         // without declaring canonical_name_fields or identity_opt_out (e.g. the
@@ -10582,6 +10714,8 @@ app.post("/unsubscribe", guestWriteRateLimit, async (req, res) => {
                 return sendError(res, 403, "FORBIDDEN", "Guest access token does not grant access to this subscription");
             }
         }
+        // Agent grants: unsubscribing corrects the subscription (active=false).
+        assertCurrentAgentMay("correct", ["subscription"], { guestCapable: true });
         await unsubscribeUser({ userId, subscription_id: parsed.data.subscription_id });
         return res.json({ success: true });
     }
@@ -11279,6 +11413,10 @@ export async function startHTTPServer() {
         }
         throw err;
     }
+    // Report the bearer handover slot (NEOTOMA_BEARER_TOKEN_PREVIOUS) at boot,
+    // so a misconfigured slot is loud at startup rather than at the first
+    // consumer's 401. Fail-closed parsing lives in services/bearer_slots.ts.
+    announceBearerHandoverStatus();
     // Initialize encryption service
     await initServerKeys();
     // Seed the built-in schema registry from ENTITY_SCHEMAS (issue #1968).