holosphere 1.3.0-alpha3 → 1.3.0-alpha5

package/content.js

@@ -1,5 +1,96 @@
 // holo_content.js
 
+/**
+ * Default deadline (ms) for the read paths' `.once()` calls. Gun's `.once()`
+ * never fires when the requested node isn't in the local graph and no peer
+ * answers (cold-start, offline, partitioned mesh) — past consumers worked
+ * around this by wrapping every `getAll` in their own `Promise.race(reject,
+ * setTimeout(8000))`. Owning it here means the spinner can never hang
+ * indefinitely on a cold path and every caller stops needing the wrapper.
+ *
+ * Pick `READ_TIMEOUT_MS = 0` (or pass `{ timeout: 0 }`) to opt out of the
+ * fallback and keep the historical "wait forever" behaviour.
+ */
+const READ_TIMEOUT_MS = 8000;
+
+/**
+ * `.once()` wrapped in a deadline. Resolves with the value when Gun fires
+ * back, or `null` after `timeoutMs` if it hasn't. Pass `timeoutMs <= 0` to
+ * disable the deadline.
+ *
+ * The first responder wins — both branches are idempotent so a late
+ * `.once()` callback after timeout is harmlessly ignored.
+ */
+function onceWithTimeout(node, timeoutMs = READ_TIMEOUT_MS) {
+    return new Promise((resolve) => {
+        let done = false;
+        const finish = (v) => { if (!done) { done = true; resolve(v); } };
+        node.once((data) => finish(data));
+        if (timeoutMs > 0) {
+            setTimeout(() => finish(null), timeoutMs);
+        }
+    });
+}
+
+/**
+ * Recursively sanitizes a value for storage in GunDB.
+ *
+ * Drops keys whose values would corrupt the graph or round-trip incorrectly:
+ *   - undefined, NaN, Infinity, -Infinity (JSON.stringify silently turns
+ *     these into nothing or "null", which is how malformed payloads like
+ *     `"initiated":,` end up in the graph and surface later as per-character
+ *     parse warnings).
+ *   - functions, symbols, bigints (not JSON-representable).
+ * Preserves null (legitimate Gun tombstone / explicit empty value).
+ * Guards against circular references.
+ *
+ * Logs one warning per dropped path so the caller can fix the producer.
+ */
+function sanitizeForStorage(value, path = '', seen = new WeakSet(), warnings = []) {
+    if (value === null) return null;
+    const t = typeof value;
+
+    if (t === 'number') {
+        if (!Number.isFinite(value)) {
+            warnings.push(`${path || '<root>'}: ${value} (non-finite number)`);
+            return undefined;
+        }
+        return value;
+    }
+    if (t === 'string' || t === 'boolean') return value;
+    if (t === 'undefined' || t === 'function' || t === 'symbol' || t === 'bigint') {
+        warnings.push(`${path || '<root>'}: ${t}`);
+        return undefined;
+    }
+
+    if (t === 'object') {
+        if (seen.has(value)) {
+            warnings.push(`${path || '<root>'}: circular reference`);
+            return undefined;
+        }
+        seen.add(value);
+
+        if (Array.isArray(value)) {
+            const out = [];
+            for (let i = 0; i < value.length; i++) {
+                const cleaned = sanitizeForStorage(value[i], `${path}[${i}]`, seen, warnings);
+                out.push(cleaned === undefined ? null : cleaned);
+            }
+            return out;
+        }
+
+        const out = {};
+        for (const k of Object.keys(value)) {
+            const cleaned = sanitizeForStorage(value[k], path ? `${path}.${k}` : k, seen, warnings);
+            if (cleaned !== undefined) out[k] = cleaned;
+        }
+        return out;
+    }
+
+    warnings.push(`${path || '<root>'}: unsupported type ${t}`);
+    return undefined;
+}
+
 /**
  * Stores content in the specified holon and lens.
  * If the target path already contains a hologram, the put operation will be
@@ -142,15 +233,38 @@ export async function put(holoInstance, holon, lens, data, password = null, opti
 
         return new Promise((resolve, reject) => {
             try {
-                // Create a copy of data, stripping read-side envelopes that
-                // must never be persisted (they're attached at resolution time).
-                let dataToStore = { ...data };
-                if (dataToStore._meta !== undefined) {
-                    delete dataToStore._meta;
-                }
-                if (dataToStore._hologram !== undefined) {
-                    delete dataToStore._hologram;
+                // Sanitize before serialization so undefined/NaN/Infinity etc.
+                // can never produce a malformed payload like `"initiated":,`
+                // (which is what causes per-character parse warnings on read).
+                const sanitizeWarnings = [];
+                let dataToStore = sanitizeForStorage(data, '', new WeakSet(), sanitizeWarnings) || {};
+                if (sanitizeWarnings.length > 0) {
+                    console.warn(
+                        `holosphere.put: sanitized ${sanitizeWarnings.length} field(s) at ${targetHolon}/${targetLens}/${targetKey} (id=${data.id}):`,
+                        sanitizeWarnings
+                    );
                 }
+                // Strip read-side envelopes that must never be persisted
+                // (they're attached at resolution time).
+                //
+                // `_hologram` and `_meta` are always read-side-only.
+                //
+                // `_federation` is also read-side for ordinary writes — it
+                // describes where data was fetched from, not where it
+                // currently lives. The one legitimate carrier is federation
+                // propagation, which writes hologram envelopes (top-level
+                // `id` + `soul`) tagged with `_federation` provenance; we
+                // detect that via `isHologram(data)` and leave it alone.
+                // Without this, a UI that reads a federated record and puts
+                // it back ends up persisting stale `_federation.origin`
+                // metadata, which then drives downstream code (federation
+                // propagators, hologram resolvers) to write or follow
+                // pointers that don't match the current storage location —
+                // producing "broken hologram" garbage-collection cascades
+                // that silently delete the user's write.
+                if (dataToStore._meta !== undefined) delete dataToStore._meta;
+                if (dataToStore._hologram !== undefined) delete dataToStore._hologram;
+                if (!isHologram && dataToStore._federation !== undefined) delete dataToStore._federation;
                 const payload = JSON.stringify(dataToStore); // The data being stored
 
                 const putCallback = async (ack) => {
@@ -335,7 +449,19 @@ export async function get(holoInstance, holon, lens, key, password = null, optio
     }
 
     // Destructure options, including visited
-    const { resolveHolograms = true, validationOptions = {}, visited } = options;
+    const {
+        resolveHolograms = true,
+        validationOptions = {},
+        visited,
+        timeout = READ_TIMEOUT_MS,
+        // `_deleted: true` is the soft-tombstone convention used by the bot,
+        // the web dashboard, and the MCP council tools. Pre-this fix the
+        // library was unaware of it and every caller filtered defensively.
+        // Now `get` returns `null` for tombstoned records by default; pass
+        // `includeDeleted: true` to surface them (admin/debug views,
+        // history reconstruction, etc.).
+        includeDeleted = false,
+    } = options;
 
     // Get schema for validation if in strict mode
     let schema = null;
@@ -379,6 +505,14 @@ export async function get(holoInstance, holon, lens, key, password = null, optio
                         return;
                     }
 
+                    // Treat the harvest-side `_deleted: true` soft-tombstone
+                    // as "not found" by default. Callers that want to see
+                    // tombstones can pass `{ includeDeleted: true }`.
+                    if (!includeDeleted && parsed._deleted === true) {
+                        resolve(null);
+                        return;
+                    }
+
                     // Check if this is a hologram that needs to be resolved
                     if (resolveHolograms && holoInstance.isHologram(parsed)) {
                         const resolvedValue = await holoInstance.resolveHologram(parsed, {
@@ -389,17 +523,20 @@ export async function get(holoInstance, holon, lens, key, password = null, optio
                         });
 
                         if (resolvedValue === null) {
-                            // This means resolveHologram determined the target doesn't exist or encountered an error
-                            console.warn(`Broken hologram detected at ${holon}/${lens}/${key}. Removing it...`);
-                            
-                            try {
-                                // Delete the broken hologram
-                                await holoInstance.delete(holon, lens, key, password);
-                                console.log(`Successfully removed broken hologram from ${holon}/${lens}/${key}`);
-                            } catch (cleanupError) {
-                                console.error(`Failed to remove broken hologram at ${holon}/${lens}/${key}:`, cleanupError);
-                            }
-                            
+                            // `resolveHologram` returned null. DON'T treat this
+                            // as a permission to delete — null fires for several
+                            // transient reasons:
+                            //   - source soul not in our local Gun graph yet
+                            //     (peer offline, federation propagation in flight)
+                            //   - maxDepth (10) reached on a deep hologram chain
+                            //   - circular reference detected mid-chain
+                            //   - any internal resolve error
+                            // None of these prove the pointer is permanently
+                            // broken, but the old behaviour `await delete(...)`
+                            // here permanently destroyed real data on the first
+                            // transient miss. Skip the entry instead; a real
+                            // garbage collector should own dead-pointer cleanup.
+                            console.warn(`Hologram at ${holon}/${lens}/${key} did not resolve (soul=${parsed.soul}); skipping.`);
                             resolve(null);
                             return;
                         }
@@ -407,7 +544,7 @@ export async function get(holoInstance, holon, lens, key, password = null, optio
                         // If it returned the hologram itself (if we ever revert to that), this logic would need adjustment.
                         // For now, assume resolvedValue is either the resolved data or we've returned null above.
 
-                        if (resolvedValue !== parsed) { 
+                        if (resolvedValue !== parsed) {
                             parsed = resolvedValue;
                         }
                     }
@@ -440,7 +577,10 @@ export async function get(holoInstance, holon, lens, key, password = null, optio
                 user.get('private').get(lens).get(key) :
                 holoInstance.gun.get(holoInstance.appname).get(holon).get(lens).get(key);
 
-            dataPath.once(handleData);
+            // `.once()` wrapped in a deadline — cold-path reads (peer offline,
+            // never-written key) used to hang forever otherwise. After
+            // `timeout` ms with no Gun response we treat it as "not found".
+            onceWithTimeout(dataPath, timeout).then(handleData);
         });
     } catch (error) {
         console.error('Error in get:', error);
@@ -454,12 +594,23 @@ export async function get(holoInstance, holon, lens, key, password = null, optio
  * @param {string} holon - The holon identifier.
  * @param {string} lens - The lens from which to retrieve content.
  * @param {string} [password] - Optional password for private holon.
+ * @param {object} [options] - Additional options.
+ * @param {number} [options.timeout=READ_TIMEOUT_MS] - Per-`.once()` deadline
+ *   (ms); the shallow probe falls back to "empty" after this on cold paths
+ *   where Gun never responds. Pass `0` to disable and keep the historical
+ *   "wait forever" behaviour.
  * @returns {Promise<Array<object>>} - The retrieved content.
  */
-export async function getAll(holoInstance, holon, lens, password = null) {
+export async function getAll(holoInstance, holon, lens, password = null, options = {}) {
     if (!holon || !lens) {
         throw new Error('getAll: Missing required parameters');
     }
+    const {
+        timeout = READ_TIMEOUT_MS,
+        // See `get` above: `_deleted: true` records are dropped from the
+        // response unless the caller opts in.
+        includeDeleted = false,
+    } = options;
 
     const schema = await holoInstance.getSchema(lens);
     if (!schema && holoInstance.strict) {
@@ -519,9 +670,12 @@ export async function getAll(holoInstance, holon, lens, password = null) {
                 holoInstance.gun.get(holoInstance.appname).get(holon).get(lens);
 
             // PASS 1: Get shallow node to determine expected item count.
-            // Retry once if empty — Gun's .once() reads from local cache, which
-            // may be cold immediately after startup before peers have synced.
-            const shallowOnce = () => new Promise((res) => dataPath.once((d) => res(d)));
+            // Wrapped in a deadline (see `onceWithTimeout`) so cold paths
+            // resolve `null` after `timeout` ms instead of hanging forever.
+            // We still retry once below — Gun's `.once()` reads from local
+            // cache, which may be cold immediately after startup before
+            // peers have synced.
+            const shallowOnce = () => onceWithTimeout(dataPath, timeout);
 
             const processShallow = (data) => {
                 if (!data) {
@@ -556,6 +710,11 @@ export async function getAll(holoInstance, holon, lens, password = null) {
                         const parsed = await holoInstance.parse(itemData);
                         if (!parsed || !parsed.id) return;
 
+                        // Drop `_deleted: true` soft-tombstones by default;
+                        // callers wanting them in the result pass
+                        // `{ includeDeleted: true }` to `getAll`.
+                        if (!includeDeleted && parsed._deleted === true) return;
+
                         if (holoInstance.isHologram(parsed)) {
                             try {
                                 const resolved = await holoInstance.resolveHologram(parsed, {
@@ -565,12 +724,11 @@ export async function getAll(holoInstance, holon, lens, password = null) {
                                 });
 
                                 if (resolved === null) {
-                                    console.warn(`Broken hologram detected in getAll for key ${key}. Removing it...`);
-                                    try {
-                                        await holoInstance.delete(holon, lens, key, password);
-                                    } catch (cleanupError) {
-                                        console.error(`Failed to remove broken hologram at ${holon}/${lens}/${key}:`, cleanupError);
-                                    }
+                                    // See `get()` above: null is not proof of a
+                                    // permanently dead pointer. Skip the entry
+                                    // without deleting so transient resolution
+                                    // failures don't destroy real data.
+                                    console.warn(`Hologram at ${holon}/${lens}/${key} did not resolve (soul=${parsed.soul}); skipping.`);
                                     return;
                                 }
 
@@ -613,11 +771,10 @@ export async function getAll(holoInstance, holon, lens, password = null) {
                         return processItem(inline, key);
                     }
                     // Otherwise fetch the leaf — sub-graph reference path.
-                    return new Promise((resolveItem) => {
-                        dataPath.get(key).once((itemData) => {
-                            processItem(itemData, key).then(resolveItem, resolveItem);
-                        });
-                    });
+                    // Same deadline as the shallow probe; a single missing
+                    // leaf can't stall the whole batch.
+                    return onceWithTimeout(dataPath.get(key), timeout)
+                        .then((itemData) => processItem(itemData, key));
                 })).then(() => resolve(Array.from(output.values())));
             };
 

package/federation.js

@@ -6,6 +6,35 @@
 import * as h3 from 'h3-js';
 import { attachHologramMeta } from './hologram.js';
 
+/**
+ * Look up a holon's display name from its `settings` lens.
+ *
+ * Returns the `name` field of the holon's settings document, or null if
+ * settings are missing or unnamed. Callers should fall back to the bare
+ * holon id when this returns null.
+ *
+ * @param {HoloSphere} holosphere
+ * @param {string} space - holon id
+ * @returns {Promise<string|null>}
+ */
+async function getHolonName(holosphere, space) {
+    if (!holosphere || !space) return null;
+    try {
+        const settings = await holosphere.get(space, 'settings', space);
+        if (!settings) return null;
+        if (Array.isArray(settings)) {
+            const found = settings.find(s => s && typeof s.name === 'string' && s.name.trim() !== '');
+            return found ? found.name : null;
+        }
+        if (typeof settings.name === 'string' && settings.name.trim() !== '') {
+            return settings.name;
+        }
+        return null;
+    } catch {
+        return null;
+    }
+}
+
 /**
  * Creates a directional federation relationship between two spaces.
  *
@@ -149,7 +178,18 @@ export async function subscribeFederation(holosphere, spaceId, password = null,
     const subscriptions = [];
     let lastNotificationTime = {};
     
+    // Cache partner display names once at setup. Each callback firing for
+    // a given partner uses the same name without re-reading settings.
+    const partnerNames = new Map();
+
     if (fedInfo.inbound && fedInfo.inbound.length > 0) {
+        await Promise.all(
+            fedInfo.inbound.map(async space => {
+                const name = await getHolonName(holosphere, space);
+                partnerNames.set(space, name);
+            })
+        );
+
         for (const federatedSpace of fedInfo.inbound) {
             // For each lens specified (or all if '*')
             for (const lens of lenses) {
@@ -158,27 +198,34 @@ export async function subscribeFederation(holosphere, spaceId, password = null,
                         try {
                             // Skip if data is missing or not from federated space
                             if (!data || !data.id) return;
-                            
+
                             // Apply throttling if configured
                             const now = Date.now();
                             const key = `${federatedSpace}_${lens}_${data.id}`;
-                            
+
                             if (throttle > 0) {
-                                if (lastNotificationTime[key] && 
+                                if (lastNotificationTime[key] &&
                                     (now - lastNotificationTime[key]) < throttle) {
                                     return; // Skip this notification (throttled)
                                 }
                                 lastNotificationTime[key] = now;
                             }
-                            
-                            // Add federation metadata if not present
-                            if (!data.federation) {
-                                data.federation = {
+
+                            // Add federation metadata if not present.
+                            // Use the canonical `_federation` envelope so it
+                            // matches what propagate() and getFederated()
+                            // produce, and what consumers (UI badges, etc.)
+                            // already check for.
+                            if (!data._federation) {
+                                const partnerName = partnerNames.get(federatedSpace);
+                                data._federation = {
                                     origin: federatedSpace,
-                                    timestamp: now
+                                    sourceLens: lens,
+                                    timestamp: now,
+                                    ...(partnerName ? { originName: partnerName } : {})
                                 };
                             }
-                            
+
                             // Execute callback with the data
                             await callback(data, federatedSpace, lens);
                         } catch (error) {
@@ -433,7 +480,7 @@ export async function removeNotify(holosphere, spaceId1, spaceId2, password1 = n
  */
 export async function getFederated(holosphere, holon, lens, options = {}) {
     // Set default options and extract queryIds
-    const { 
+    const {
         queryIds = null, // New option
         aggregate = false,
         idField = 'id',
@@ -443,9 +490,16 @@ export async function getFederated(holosphere, holon, lens, options = {}) {
         mergeStrategy = null,
         includeLocal = true,
         includeFederated = true,
-        resolveReferences = true, 
+        resolveReferences = true,
         maxFederatedSpaces = -1,
-        timeout = 10000
+        timeout = 10000,
+        // When `resolveReferences` is on, source-soul fetches that fail get
+        // replaced with `{ id, _hologram: { isHologram: false, error } }`
+        // error stubs (federation.js around line 654). By default we filter
+        // those out of the response so consumers never render broken-card
+        // placeholders. Set `includeUnresolvedStubs: true` if you actually
+        // want to surface the failure to the user (e.g. an admin/debug view).
+        includeUnresolvedStubs = false
     } = options;
     
     console.log(`resolveReferences option: ${resolveReferences}`);
@@ -476,10 +530,37 @@ export async function getFederated(holosphere, holon, lens, options = {}) {
         spacesToQuery = spacesToQuery.concat(federatedSpaces);
     }
 
+    // Resolve display names for federated partner spaces in parallel, so
+    // every tagged item can carry the holon's name. Compute once per call.
+    const remoteSpaces = spacesToQuery.filter(s => s !== holon);
+    const spaceNames = new Map();
+    await Promise.all(
+        remoteSpaces.map(async space => {
+            const name = await getHolonName(holosphere, space);
+            spaceNames.set(space, name);
+        })
+    );
+
+    // Tag items pulled from a federated partner with the space they came
+    // from (and its resolved display name, if any). Local items are left
+    // untouched so consumers can distinguish own vs. external by absence
+    // or presence of `_federation`.
+    const tagWithSource = (item, space) => {
+        if (!item || space === holon) return item;
+        const originName = spaceNames.get(space);
+        const fed = {
+            ...(item._federation || {}),
+            origin: space,
+            sourceLens: lens
+        };
+        if (originName) fed.originName = originName;
+        return { ...item, _federation: fed };
+    };
+
     // Fetch data from all relevant spaces
     for (const currentSpace of spacesToQuery) {
         if (queryIds && Array.isArray(queryIds)) {
-            // --- Fetch specific IDs using holosphere.get --- 
+            // --- Fetch specific IDs using holosphere.get ---
             console.log(`Fetching specific IDs from ${currentSpace}: ${queryIds.join(', ')}`);
             for (const itemId of queryIds) {
                 if (fetchedItems.has(itemId)) continue; // Skip if already fetched
@@ -487,7 +568,7 @@ export async function getFederated(holosphere, holon, lens, options = {}) {
                     holosphere.get(currentSpace, lens, itemId)
                         .then(item => {
                             if (item) {
-                                fetchedItems.set(itemId, item);
+                                fetchedItems.set(itemId, tagWithSource(item, currentSpace));
                             }
                         })
                         .catch(err => console.warn(`Error fetching item ${itemId} from ${currentSpace}: ${err.message}`))
@@ -504,7 +585,7 @@ export async function getFederated(holosphere, holon, lens, options = {}) {
                     .then(items => {
                         for (const item of items) {
                             if (item && item[idField] && !fetchedItems.has(item[idField])) {
-                                fetchedItems.set(item[idField], item);
+                                fetchedItems.set(item[idField], tagWithSource(item, currentSpace));
                             }
                         }
                     })
@@ -554,7 +635,26 @@ export async function getFederated(holosphere, holon, lens, options = {}) {
                         if (originalData) {
                             // Replace the reference with the resolved data, attaching
                             // the canonical _hologram envelope (single source of truth).
-                            result[i] = attachHologramMeta(originalData, item.soul);
+                            const withMeta = attachHologramMeta(originalData, item.soul);
+                            // Stamp the source holon's display name so consumers
+                            // don't need a second round-trip to render it. Use
+                            // the per-call cache when possible to avoid duplicate
+                            // settings reads across many holograms from the same
+                            // source.
+                            if (withMeta._hologram?.sourceHolon) {
+                                let sourceHolonName = spaceNames.get(withMeta._hologram.sourceHolon);
+                                if (sourceHolonName === undefined) {
+                                    sourceHolonName = await getHolonName(holosphere, withMeta._hologram.sourceHolon);
+                                    spaceNames.set(withMeta._hologram.sourceHolon, sourceHolonName);
+                                }
+                                if (sourceHolonName) {
+                                    withMeta._hologram = {
+                                        ...withMeta._hologram,
+                                        sourceHolonName
+                                    };
+                                }
+                            }
+                            result[i] = withMeta;
                         } else {
                             // Original data not found — keep the id so callers can
                             // identify the broken reference, and surface the error.
@@ -644,14 +744,28 @@ export async function getFederated(holosphere, holon, lens, options = {}) {
                 count: group.length,
                 timestamp: Date.now()
             };
-            
+
             return base;
         });
-        
-        return aggregatedData;
+
+        return includeUnresolvedStubs ? aggregatedData : aggregatedData.filter(isResolved);
     }
-    
-    return result;
+
+    return includeUnresolvedStubs ? result : result.filter(isResolved);
+}
+
+/**
+ * True for any record that isn't an unresolved-reference error stub.
+ *
+ * `getFederated` produces stubs of the shape
+ * `{ id, _hologram: { isHologram: false, error, ... } }` when a source
+ * soul can't be resolved (peer offline, federation in flight, etc.).
+ * Default response now filters those out so consumers don't render
+ * broken-card placeholders.
+ */
+function isResolved(item) {
+    if (!item || typeof item !== 'object') return false;
+    return item._hologram?.isHologram !== false;
 }
 
 /**
@@ -702,7 +816,12 @@ export async function propagate(holosphere, holon, lens, data, options = {}) {
         
         // Only propagate if we have outbound partners configured.
         if (fedInfo && fedInfo.outbound && fedInfo.outbound.length > 0) {
-            let spaces = fedInfo.outbound;
+            // Never propagate back to ourselves. Writing a hologram to the
+            // source holon overwrites the original data with a self-
+            // referencing pointer, and HoloSphere's get() then auto-deletes
+            // it as a "broken hologram" (resolveHologram returns null because
+            // the soul resolves to itself), silently destroying the entry.
+            let spaces = fedInfo.outbound.filter(s => String(s) !== String(holon));
 
             if (targetSpaces && Array.isArray(targetSpaces) && targetSpaces.length > 0) {
                 spaces = spaces.filter(space => targetSpaces.includes(space));
@@ -732,6 +851,11 @@ export async function propagate(holosphere, holon, lens, data, options = {}) {
                     // Check if data is already a hologram
                     const isAlreadyHologram = holosphere.isHologram(data);
 
+                    // Resolve our own holon's name once so every propagated
+                    // payload carries it. Falls back to undefined (the field
+                    // is omitted) so consumers can use the bare holon id.
+                    const ownName = await getHolonName(holosphere, holon);
+
                     // For each target space, propagate the data
                     const propagatePromises = spaces.map(async (targetSpace) => {
                         try {
@@ -740,7 +864,8 @@ export async function propagate(holosphere, holon, lens, data, options = {}) {
                                 origin: holon,       // The space from which this data is being propagated
                                 sourceLens: lens,    // The lens from which this data is being propagated
                                 propagatedAt: Date.now(),
-                                originalId: data.id
+                                originalId: data.id,
+                                ...(ownName ? { originName: ownName } : {})
                             };
 
                             if (useHolograms && !isAlreadyHologram) {
@@ -761,11 +886,19 @@ export async function propagate(holosphere, holon, lens, data, options = {}) {
                                     }
                                 };
                             }
-                            
+
+                            // Defensive: even if the outbound list somehow
+                            // contains the source holon, never write a self-
+                            // hologram. The source already has the original.
+                            if (String(targetSpace) === String(holon)) {
+                                result.skipped++;
+                                return true;
+                            }
+
                             // Store in the target space with redirection disabled and no further auto-propagation
-                            await holosphere.put(targetSpace, lens, payloadToPut, null, { 
-                                disableHologramRedirection: true, 
-                                autoPropagate: false 
+                            await holosphere.put(targetSpace, lens, payloadToPut, null, {
+                                disableHologramRedirection: true,
+                                autoPropagate: false
                             });
 
                             result.success++;
@@ -847,7 +980,11 @@ export async function propagate(holosphere, holon, lens, data, options = {}) {
                         
                         // Check if data is already a hologram (reuse from federation section)
                         const isAlreadyHologram = holosphere.isHologram(data);
-                        
+
+                        // Resolve our own holon's name once for parent propagation
+                        // (same as the federation block above).
+                        const ownNameParent = await getHolonName(holosphere, holon);
+
                         // Propagate to each parent hexagon
                         const parentPropagatePromises = parentHexagons.map(async (parentHexagon) => {
                             try {
@@ -858,7 +995,8 @@ export async function propagate(holosphere, holon, lens, data, options = {}) {
                                     propagatedAt: Date.now(),
                                     originalId: data.id,
                                     propagationType: 'parent', // Indicate this is parent propagation
-                                    parentLevel: holonResolution - h3.getResolution(parentHexagon) // How many levels up
+                                    parentLevel: holonResolution - h3.getResolution(parentHexagon), // How many levels up
+                                    ...(ownNameParent ? { originName: ownNameParent } : {})
                                 };
 
                                 if (useHolograms && !isAlreadyHologram) {