holosphere 2.0.0-alpha11 → 2.0.0-alpha12

package/src/federation/handshake.js

@@ -15,8 +15,11 @@ import {
   createDMEvent,
   hexToNpub,
   generateNonce,
+  getPublicKey,
 } from '../crypto/nostr-utils.js';
 import { addFederatedPartner, storeInboundCapability } from './registry.js';
+import { issueCapability } from '../crypto/secp256k1.js';
+import * as cardStorage from './card-storage.js';
 
 // ============================================================================
 // Types (documented for reference)
@@ -200,17 +203,36 @@ export async function sendFederationResponse(client, privateKey, recipientPubKey
  * @param {Object} handlers
  * @param {Function} handlers.onRequest - Called with (request, senderPubKey)
  * @param {Function} handlers.onResponse - Called with (response, senderPubKey)
+ * @param {Object} options - Subscription options
+ * @param {string} options.appname - Application namespace (for persistent storage)
  * @returns {Function} Unsubscribe function
  */
-export function subscribeToFederationDMs(client, privateKey, publicKey, handlers) {
+export function subscribeToFederationDMs(client, privateKey, publicKey, handlers, options = {}) {
   const { onRequest, onResponse } = handlers;
+  const { appname } = options;
   let isActive = true;
+
+  // In-memory deduplication for this session
   const processedEventIds = new Set();
 
+  // Track processed responses persistently to prevent duplicate notifications
+  let processedResponseIds = new Set();
+
+  // Load processed responses from storage if appname is provided
+  const loadProcessedResponses = async () => {
+    if (appname && client?.client) {
+      try {
+        processedResponseIds = await cardStorage.getProcessedResponseIds(client.client, appname);
+      } catch (err) {
+        console.warn('[Handshake] Could not load processed responses:', err.message);
+      }
+    }
+  };
+
   const handleEvent = async (event) => {
     if (!isActive) return;
 
-    // Skip duplicates
+    // Skip duplicates (in-memory check for this session)
     if (processedEventIds.has(event.id)) return;
     processedEventIds.add(event.id);
 
@@ -234,9 +256,31 @@ export function subscribeToFederationDMs(client, privateKey, publicKey, handlers
       const payload = JSON.parse(decrypted);
 
       if (payload.type === 'federation_request' && payload.version === '1.0') {
+        // Check if this request was already dismissed
+        if (appname && client?.client) {
+          const isDismissed = await cardStorage.isRequestDismissed(client.client, appname, payload.requestId);
+          if (isDismissed) {
+            console.log('[Handshake] Skipping dismissed request:', payload.requestId);
+            return;
+          }
+        }
+
         console.log('[Handshake] Received federation request from:', event.pubkey.substring(0, 8) + '...');
         onRequest?.(payload, event.pubkey);
       } else if (payload.type === 'federation_response' && payload.version === '1.0') {
+        // Check if this response was already processed (persistent check)
+        const responseKey = `${payload.requestId}_${event.pubkey}`;
+        if (processedResponseIds.has(responseKey)) {
+          console.log('[Handshake] Skipping already processed response:', responseKey);
+          return;
+        }
+
+        // Mark as processed in persistent storage
+        if (appname && client?.client) {
+          await cardStorage.markResponseProcessed(client.client, appname, payload.requestId, event.pubkey);
+          processedResponseIds.add(responseKey);
+        }
+
         console.log('[Handshake] Received federation response from:', event.pubkey.substring(0, 8) + '...');
         onResponse?.(payload, event.pubkey);
       }
@@ -250,6 +294,9 @@ export function subscribeToFederationDMs(client, privateKey, publicKey, handlers
   let subscription = null;
 
   const startSubscription = async () => {
+    // Load processed responses first
+    await loadProcessedResponses();
+
     // Get the NostrClient from HoloSphere instance
     const nostrClient = client?.client;
     if (!nostrClient?.subscribe) {
@@ -313,16 +360,39 @@ export async function initiateFederationHandshake(holosphere, privateKey, params
 
   try {
     // Get sender's public key
-    const { getPublicKey } = await import('../crypto/nostr-utils.js');
     const senderPubKey = getPublicKey(privateKey);
 
+    // Issue capabilities for outbound lenses (lenses we're sharing with partner)
+    const capabilities = [];
+    for (const lensName of (lensConfig.outbound || [])) {
+      try {
+        const token = await issueCapability(
+          ['read'],
+          { holonId, lensName, dataId: '*' },
+          partnerPubKey,
+          {
+            expiresIn: 365 * 24 * 60 * 60 * 1000, // 1 year
+            issuer: senderPubKey,
+            issuerKey: privateKey,
+          }
+        );
+        capabilities.push({
+          token,
+          scope: { holonId, lensName },
+          permissions: ['read'],
+        });
+      } catch (err) {
+        console.warn(`[Handshake] Failed to issue capability for ${lensName}:`, err.message);
+      }
+    }
+
     // Create federation request
     const request = createFederationRequest({
       senderHolonId: holonId,
       senderHolonName: holonName,
       senderPubKey,
       lensConfig,
-      capabilities: [],
+      capabilities,
       message,
     });
 
@@ -373,7 +443,6 @@ export async function acceptFederationRequest(holosphere, privateKey, params) {
 
   try {
     // Get responder's public key
-    const { getPublicKey } = await import('../crypto/nostr-utils.js');
     const responderPubKey = getPublicKey(privateKey);
 
     // Add sender as federated partner in Nostr registry
@@ -399,6 +468,30 @@ export async function acceptFederationRequest(holosphere, privateKey, params) {
       partnerName: request.senderHolonName
     });
 
+    // Issue capabilities for our outbound lenses (lenses we're sharing with partner)
+    const capabilities = [];
+    for (const lensName of (lensConfig.outbound || [])) {
+      try {
+        const token = await issueCapability(
+          ['read'],
+          { holonId, lensName, dataId: '*' },
+          senderPubKey,
+          {
+            expiresIn: 365 * 24 * 60 * 60 * 1000, // 1 year
+            issuer: responderPubKey,
+            issuerKey: privateKey,
+          }
+        );
+        capabilities.push({
+          token,
+          scope: { holonId, lensName },
+          permissions: ['read'],
+        });
+      } catch (err) {
+        console.warn(`[Handshake] Failed to issue capability for ${lensName}:`, err.message);
+      }
+    }
+
     // Create and send response
     const response = createFederationResponse({
       requestId: request.requestId,
@@ -407,14 +500,50 @@ export async function acceptFederationRequest(holosphere, privateKey, params) {
       responderHolonName: holonName,
       responderPubKey,
       lensConfig,
-      capabilities: [],
+      capabilities,
       message,
     });
 
     const sent = await sendFederationResponse(holosphere.client, privateKey, senderPubKey, response);
 
     if (sent) {
-      return { success: true };
+      // Dismiss the request so it won't reappear
+      if (holosphere.client && request.requestId) {
+        await cardStorage.dismissRequest(holosphere.client, holosphere.config.appName, request.requestId);
+        console.log('[Handshake] Request dismissed after acceptance:', request.requestId);
+      }
+
+      // Auto-receive federated lens data as holograms for configured inbound lenses
+      // This enables the user to immediately see the partner's data in their holon
+      const receivedHolograms = {};
+      const inboundLenses = lensConfig.inbound || [];
+
+      if (inboundLenses.length > 0 && holosphere.receiveFederatedLens) {
+        console.log('[Handshake] Receiving federated lens data as holograms...');
+
+        for (const lensName of inboundLenses) {
+          try {
+            // The sender's holon ID comes from the request
+            const senderHolonId = request.senderHolonId;
+
+            const result = await holosphere.receiveFederatedLens(
+              senderPubKey,
+              senderHolonId,
+              lensName,
+              holonId,
+              { overwrite: false }
+            );
+
+            receivedHolograms[lensName] = result;
+            console.log(`[Handshake] Received ${result.received} holograms for lens "${lensName}"`);
+          } catch (err) {
+            console.warn(`[Handshake] Failed to receive holograms for lens "${lensName}":`, err.message);
+            receivedHolograms[lensName] = { error: err.message };
+          }
+        }
+      }
+
+      return { success: true, requestId: request.requestId, receivedHolograms };
     } else {
       return { success: false, error: 'Failed to send response DM' };
     }
@@ -452,6 +581,74 @@ export async function rejectFederationRequest(holosphere, privateKey, params) {
   }
 }
 
+/**
+ * Process a federation response (called by initiator when receiving acceptance)
+ * Stores capabilities from the responder in the local registry and receives holograms
+ * @param {Object} holosphere - HoloSphere instance
+ * @param {Object} response - Federation response payload
+ * @param {string} responderPubKey - Responder's public key
+ * @param {Object} [options={}] - Processing options
+ * @param {string} [options.holonId] - Initiator's holon ID (for receiving holograms)
+ * @param {string[]} [options.inboundLenses] - Lenses to receive from responder
+ * @returns {Promise<Object>} Result with success, stored capability count, and received holograms
+ */
+export async function processFederationResponse(holosphere, response, responderPubKey, options = {}) {
+  if (!response || response.status !== 'accepted') {
+    return { success: false, error: 'Response not accepted', storedCapabilities: 0 };
+  }
+
+  const { holonId, inboundLenses = [] } = options;
+  let storedCapabilities = 0;
+
+  // Store capabilities from the responder
+  if (holosphere.client && response.capabilities && response.capabilities.length > 0) {
+    for (const cap of response.capabilities) {
+      try {
+        await storeInboundCapability(holosphere.client, holosphere.config.appName, responderPubKey, cap);
+        storedCapabilities++;
+      } catch (err) {
+        console.warn(`[Handshake] Failed to store capability:`, err.message);
+      }
+    }
+  }
+
+  // Add responder as federated partner if not already
+  if (holosphere.client) {
+    await addFederatedPartner(holosphere.client, holosphere.config.appName, responderPubKey, {
+      alias: response.responderHolonName,
+      addedVia: 'handshake_accepted',
+    });
+  }
+
+  // Auto-receive federated lens data as holograms for configured inbound lenses
+  const receivedHolograms = {};
+  const responderHolonId = response.responderHolonId;
+
+  if (holonId && responderHolonId && inboundLenses.length > 0 && holosphere.receiveFederatedLens) {
+    console.log('[Handshake] Receiving federated lens data as holograms from responder...');
+
+    for (const lensName of inboundLenses) {
+      try {
+        const result = await holosphere.receiveFederatedLens(
+          responderPubKey,
+          responderHolonId,
+          lensName,
+          holonId,
+          { overwrite: false }
+        );
+
+        receivedHolograms[lensName] = result;
+        console.log(`[Handshake] Received ${result.received} holograms for lens "${lensName}"`);
+      } catch (err) {
+        console.warn(`[Handshake] Failed to receive holograms for lens "${lensName}":`, err.message);
+        receivedHolograms[lensName] = { error: err.message };
+      }
+    }
+  }
+
+  return { success: true, storedCapabilities, receivedHolograms };
+}
+
 // ============================================================================
 // Payload Validation
 // ============================================================================

package/src/federation/hologram.js

@@ -1,17 +1,23 @@
 /**
- * @fileoverview Federation and Hologram (Reference) Management.
+ * @fileoverview Unified Federation and Hologram (Reference) Management.
  *
  * Provides hologram (lightweight reference) creation, resolution, and management.
  * Holograms enable data to appear in multiple holons while maintaining a single
- * source of truth. Supports circular reference detection and cross-holosphere
- * federation with capability-based access control.
+ * source of truth.
+ *
+ * UNIFIED MODEL: All federation is capability-based. Every hologram includes:
+ * - authorPubKey: The public key of the data owner (can be self)
+ * - capability: A capability token (self-issued for same-author federation)
+ *
+ * This unifies "in-federation" (same author) and "cross-federation" (different authors)
+ * into a single consistent model.
  *
  * @module federation/hologram
  */
 
 import { buildPath, write, read, update } from '../storage/unified-storage.js';
-import { verifyCapability } from '../crypto/secp256k1.js';
-import { getCapabilityForAuthor } from './registry.js';
+import { verifyCapability, issueCapability } from '../crypto/secp256k1.js';
+import { getCapabilityForAuthor, storeInboundCapability } from './registry.js';
 
 /** @constant {number} Maximum depth for hologram resolution chain */
 const MAX_RESOLUTION_DEPTH = 10;
@@ -79,19 +85,32 @@ export async function wouldCreateCircularHologram(client, appname, sourceHolon,
 }
 
 /**
- * Create a hologram (lightweight reference)
+ * Create a hologram (lightweight reference) - UNIFIED MODEL
+ *
+ * All holograms now include authorPubKey and capability for consistency.
+ * This unifies "in-federation" (same author) and "cross-federation" (different authors).
+ *
  * @param {string} sourceHolon - Source holon ID
  * @param {string} targetHolon - Target holon ID
  * @param {string} lensName - Lens name
  * @param {string} dataId - Data ID
  * @param {string} appname - Application namespace
- * @param {Object} options - Optional cross-holosphere settings
- * @param {string} options.authorPubKey - Source author's public key (for cross-holosphere)
- * @param {string} options.capability - Capability token (for cross-holosphere)
- * @returns {Object} Hologram object
+ * @param {Object} options - Hologram options (authorPubKey and capability are required)
+ * @param {string} options.authorPubKey - Source author's public key (REQUIRED - can be self)
+ * @param {string} options.capability - Capability token (REQUIRED - self-issued for same author)
+ * @returns {Object} Hologram object with unified structure
+ * @throws {Error} If authorPubKey or capability is missing
  */
 export function createHologram(sourceHolon, targetHolon, lensName, dataId, appname, options = {}) {
-  const { authorPubKey = null, capability = null } = options;
+  const { authorPubKey, capability } = options;
+
+  // Validate required fields for unified model
+  if (!authorPubKey) {
+    throw new Error('authorPubKey is required for hologram creation (unified model)');
+  }
+  if (!capability) {
+    throw new Error('capability is required for hologram creation (unified model)');
+  }
 
   const soul = buildPath(appname, sourceHolon, lensName, dataId);
 
@@ -104,32 +123,95 @@ export function createHologram(sourceHolon, targetHolon, lensName, dataId, appna
       holonId: sourceHolon,
       lensName,
       dataId,
+      authorPubKey,  // Always present in unified model
     },
+    capability,  // Always present in unified model
     _meta: {
       created: Date.now(),
       sourceHolon,
       source: sourceHolon,  // Alias for compatibility
+      sourcePubKey: authorPubKey,
+      grantedAt: Date.now(),
     },
   };
 
-  // Cross-holosphere enhancements
-  if (authorPubKey) {
-    hologram.crossHolosphere = true;
-    hologram.target.authorPubKey = authorPubKey;
-    hologram._meta.sourcePubKey = authorPubKey;
-  }
+  return hologram;
+}
+
+/**
+ * Create a hologram with automatic capability issuance - UNIFIED MODEL
+ *
+ * This is the preferred method for creating holograms. It automatically issues
+ * a capability token (self-capability if same author, cross-capability otherwise).
+ *
+ * @param {Object} client - Nostr client instance (must have publicKey and optionally privateKey)
+ * @param {string} sourceHolon - Source holon ID
+ * @param {string} targetHolon - Target holon ID
+ * @param {string} lensName - Lens name
+ * @param {string} dataId - Data ID
+ * @param {string} appname - Application namespace
+ * @param {Object} options - Hologram options
+ * @param {string} [options.sourceAuthorPubKey] - Source author's public key (defaults to client.publicKey)
+ * @param {string} [options.targetAuthorPubKey] - Target author's public key (defaults to client.publicKey)
+ * @param {string} [options.capability] - Pre-issued capability (if not provided, one will be issued)
+ * @param {string[]} [options.permissions=['read']] - Permissions for auto-issued capability
+ * @param {number} [options.expiresIn] - Capability expiration (null for self-caps = no expiration)
+ * @returns {Promise<Object>} Hologram object with unified structure
+ */
+export async function createHologramWithCapability(client, sourceHolon, targetHolon, lensName, dataId, appname, options = {}) {
+  const {
+    sourceAuthorPubKey = client.publicKey,
+    targetAuthorPubKey = client.publicKey,
+    capability: providedCapability = null,
+    permissions = ['read'],
+    expiresIn = null,
+  } = options;
+
+  let capability = providedCapability;
+
+  // Issue capability if not provided
+  if (!capability) {
+    const isSelfCapability = sourceAuthorPubKey === targetAuthorPubKey;
+
+    // Issue capability - for self-caps, no expiration by default
+    capability = await issueCapability(
+      permissions,
+      { holonId: sourceHolon, lensName, dataId },
+      targetAuthorPubKey,
+      {
+        expiresIn: expiresIn !== null ? expiresIn : (isSelfCapability ? 365 * 24 * 60 * 60 * 1000 : 3600000), // 1 year for self, 1 hour for cross
+        issuer: sourceAuthorPubKey,
+        issuerKey: client.privateKey,
+      }
+    );
 
-  if (capability) {
-    hologram.capability = capability;
-    hologram._meta.grantedAt = Date.now();
+    // Store the capability in registry for cross-author federation
+    if (!isSelfCapability && client.privateKey) {
+      await storeInboundCapability(client, appname, sourceAuthorPubKey, {
+        token: capability,
+        scope: { holonId: sourceHolon, lensName, dataId },
+        permissions,
+        isSelfCapability: false,
+      });
+    }
   }
 
-  return hologram;
+  return createHologram(sourceHolon, targetHolon, lensName, dataId, appname, {
+    authorPubKey: sourceAuthorPubKey,
+    capability,
+  });
 }
 
 /**
- * Resolve hologram to actual data, merging local overrides
- * Supports cross-holosphere holograms with capability token verification
+ * Resolve hologram to actual data, merging local overrides - UNIFIED MODEL
+ *
+ * In the unified model, ALL holograms have authorPubKey and capability.
+ * Resolution always:
+ * 1. Verifies the capability token
+ * 2. Fetches data with author filter
+ *
+ * This provides consistent security for both self and cross-author holograms.
+ *
  * @param {Object} client - Nostr client instance
  * @param {Object} hologram - Hologram object
  * @param {Set} visited - Visited souls (circular reference detection)
@@ -138,10 +220,11 @@ export function createHologram(sourceHolon, targetHolon, lensName, dataId, appna
  * @param {string} options.appname - Application namespace (for registry lookup)
  * @param {boolean} options.deleteCircular - If true, delete circular holograms when detected (default: true)
  * @param {string} options.hologramPath - Path of the hologram being resolved (for deletion)
+ * @param {boolean} options.skipCapabilityVerification - Skip capability check (for internal use only)
  * @returns {Promise<Object|null>} Resolved data with _hologram metadata, or null
  */
 export async function resolveHologram(client, hologram, visited = new Set(), chain = [], options = {}) {
-  const { deleteCircular = true, hologramPath = null } = options;
+  const { deleteCircular = true, hologramPath = null, skipCapabilityVerification = false } = options;
 
   if (!hologram || !hologram.hologram) {
     return hologram; // Not a hologram, return as-is
@@ -192,31 +275,32 @@ export async function resolveHologram(client, hologram, visited = new Set(), cha
 
   let sourceData;
 
-  // Handle cross-holosphere holograms
-  if (hologram.crossHolosphere && target.authorPubKey) {
-    // Get capability - try embedded first, then registry fallback
-    let capability = hologram.capability;
-
-    if (!capability && options.appname) {
-      // Fallback to registry lookup
-      const capEntry = await getCapabilityForAuthor(
-        client,
-        options.appname,
-        target.authorPubKey,
-        {
-          holonId: target.holonId,
-          lensName: target.lensName,
-          dataId: target.dataId,
-        }
-      );
-      if (capEntry) {
-        capability = capEntry.token;
+  // UNIFIED MODEL: All holograms have authorPubKey and capability
+  // Get capability - try embedded first, then registry fallback
+  let capability = hologram.capability;
+  const authorPubKey = target.authorPubKey;
+
+  if (!capability && options.appname && authorPubKey) {
+    // Fallback to registry lookup
+    const capEntry = await getCapabilityForAuthor(
+      client,
+      options.appname,
+      authorPubKey,
+      {
+        holonId: target.holonId,
+        lensName: target.lensName,
+        dataId: target.dataId,
       }
+    );
+    if (capEntry) {
+      capability = capEntry.token;
     }
+  }
 
-    // Verify capability before resolving
+  // Verify capability (unified model - always verify unless explicitly skipped)
+  if (!skipCapabilityVerification) {
     if (!capability) {
-      console.warn(`❌ Cross-holosphere hologram missing capability: ${soul}`);
+      console.warn(`❌ Hologram missing capability: ${soul}`);
       return null;
     }
 
@@ -231,16 +315,18 @@ export async function resolveHologram(client, hologram, visited = new Set(), cha
     );
 
     if (!isValid) {
-      console.warn(`❌ Capability verification failed for cross-holosphere hologram: ${soul}`);
+      console.warn(`❌ Capability verification failed for hologram: ${soul}`);
       return null;
     }
+  }
 
-    // Read from federated source (different author)
+  // UNIFIED MODEL: Always fetch with author filter if authorPubKey is present
+  if (authorPubKey) {
     sourceData = await read(client, soul, {
-      authors: [target.authorPubKey]
+      authors: [authorPubKey]
     });
   } else {
-    // Same-holosphere resolution (original behavior)
+    // Legacy fallback for holograms without authorPubKey
     sourceData = await read(client, soul);
   }
 
@@ -259,7 +345,7 @@ export async function resolveHologram(client, hologram, visited = new Set(), cha
 }
 
 /**
- * Merge hologram local overrides with source data
+ * Merge hologram local overrides with source data - UNIFIED MODEL
  * @private
  * @param {Object} hologram - Hologram object
  * @param {Object} sourceData - Source data
@@ -267,7 +353,7 @@ export async function resolveHologram(client, hologram, visited = new Set(), cha
  */
 function mergeHologramWithSource(hologram, sourceData) {
   // Extract local overrides from the hologram (exclude hologram-specific fields)
-  const hologramOnlyFields = ['hologram', 'soul', 'target', '_meta', 'id', 'capability', 'crossHolosphere'];
+  const hologramOnlyFields = ['hologram', 'soul', 'target', '_meta', 'id', 'capability'];
   const localOverrides = {};
   const localOverrideKeys = [];
 
@@ -280,6 +366,8 @@ function mergeHologramWithSource(hologram, sourceData) {
 
   // Merge: source data + local overrides + hologram metadata
   const sourceHolon = hologram._meta?.sourceHolon || hologram._meta?.source || hologram.target?.holonId;
+  const sourcePubKey = hologram.target?.authorPubKey || hologram._meta?.sourcePubKey || null;
+
   const resolved = {
     ...sourceData,           // Original data from source
     ...localOverrides,       // Local overrides (x, y, pinned, etc.)
@@ -288,8 +376,7 @@ function mergeHologramWithSource(hologram, sourceData) {
       soul: hologram.soul,
       sourceHolon: sourceHolon,
       localOverrides: localOverrideKeys,
-      crossHolosphere: hologram.crossHolosphere || false,
-      sourcePubKey: hologram._meta?.sourcePubKey || null,
+      sourcePubKey: sourcePubKey,  // Always present in unified model
     }
   };
 
@@ -340,14 +427,21 @@ export async function setupFederation(
 }
 
 /**
- * Propagate data to federated location
- * @param {Object} client - Nostr client instance
+ * Propagate data to federated location - UNIFIED MODEL
+ *
+ * In the unified model, all holograms require authorPubKey and capability.
+ * This function automatically issues capabilities for propagation.
+ *
+ * @param {Object} client - Nostr client instance (must have publicKey)
  * @param {string} appname - Application namespace
  * @param {Object} data - Data to propagate
  * @param {string} sourceHolon - Source holon ID
  * @param {string} targetHolon - Target holon ID
  * @param {string} lensName - Lens name
  * @param {string} mode - 'reference' or 'copy'
+ * @param {Object} options - Propagation options
+ * @param {string} [options.sourceAuthorPubKey] - Source author (defaults to client.publicKey)
+ * @param {string} [options.capability] - Pre-issued capability (auto-issued if not provided)
  * @returns {Promise<boolean>} Success indicator
  */
 export async function propagateData(
@@ -357,7 +451,8 @@ export async function propagateData(
   sourceHolon,
   targetHolon,
   lensName,
-  mode = 'reference'
+  mode = 'reference',
+  options = {}
 ) {
   const dataId = data.id;
 
@@ -490,8 +585,22 @@ export async function propagateData(
       return false;
     }
 
-    // Create hologram in target
-    const hologram = createHologram(sourceHolon, targetHolon, lensName, dataId, appname);
+    // UNIFIED MODEL: Create hologram with capability
+    const sourceAuthorPubKey = options.sourceAuthorPubKey || client.publicKey;
+    const hologram = await createHologramWithCapability(
+      client,
+      sourceHolon,
+      targetHolon,
+      lensName,
+      dataId,
+      appname,
+      {
+        sourceAuthorPubKey,
+        capability: options.capability,
+        permissions: ['read'],
+      }
+    );
+
     const targetPath = buildPath(appname, targetHolon, lensName, dataId);
     const success = await write(client, targetPath, hologram);