ultravisor 1.0.24 → 1.0.26

package/source/services/Ultravisor-Beacon-Coordinator.cjs

@@ -113,6 +113,62 @@ class UltravisorBeaconCoordinator extends libPictService
 		return (tmpStore && tmpStore.isEnabled && tmpStore.isEnabled()) ? tmpStore : null;
 	}
 
+	/**
+	 * Get the queue persistence bridge (lazy). Falls back to direct
+	 * QueueStore writes when the bridge isn't installed (older
+	 * deployments, tests).
+	 *
+	 * @returns {object|null}
+	 */
+	_getQueuePersistenceBridge()
+	{
+		let tmpMap = this.fable.servicesMap && this.fable.servicesMap.UltravisorQueuePersistenceBridge;
+		if (!tmpMap) return null;
+		return Object.values(tmpMap)[0] || null;
+	}
+
+	/**
+	 * Capabilities the bridge skips persistence for. Their own dispatches
+	 * are themselves work items; recording them would loop:
+	 *   QueuePersistence    → QP_AppendEvent → enqueueWorkItem → QP_AppendEvent → ...
+	 *   ManifestStore       → MS_UpsertManifest → enqueueWorkItem → MS_UpsertManifest → ...
+	 *   MeadowProxy         → MeadowProxy.Request (the bridge's new dispatch
+	 *                         backend) → enqueueWorkItem → MeadowProxy.Request → ...
+	 *   DataBeaconSchema    → bootstrap-time EnsureSchema/IntrospectSchema; same loop hazard.
+	 *   DataBeaconManagement → bootstrap-time EnableEndpoint/UpdateProxyConfig; same loop hazard.
+	 * The set lives on the coordinator because it's the only place that
+	 * decides "is this work item worth persisting?".
+	 */
+	_isMetaCapability(pCapability)
+	{
+		return pCapability === 'QueuePersistence'
+			|| pCapability === 'ManifestStore'
+			|| pCapability === 'MeadowProxy'
+			|| pCapability === 'DataBeaconSchema'
+			|| pCapability === 'DataBeaconManagement';
+	}
+
+	/**
+	 * Centralized fire-and-forget for bridge calls. Promise rejections
+	 * land here as warnings instead of unhandled-rejection events,
+	 * matching the original `try { ... } catch (...)` best-effort
+	 * shape of every legacy QueueStore call site.
+	 */
+	_persistBest(pPromise, pLabel)
+	{
+		if (!pPromise || typeof pPromise.then !== 'function') return;
+		pPromise.then((pResult) =>
+		{
+			if (pResult && pResult.Success === false && pResult.Reason)
+			{
+				this.log.warn(`BeaconCoordinator: ${pLabel}: ${pResult.Reason}`);
+			}
+		}).catch((pErr) =>
+		{
+			this.log.warn(`BeaconCoordinator: ${pLabel} threw: ${(pErr && pErr.message) || pErr}`);
+		});
+	}
+
 	/**
 	 * Get the scheduler service (lazy lookup).
 	 *
@@ -242,9 +298,19 @@ class UltravisorBeaconCoordinator extends libPictService
 	{
 		let tmpName = pBeaconInfo.Name || 'unnamed';
 
-		// Check for an existing offline beacon with the same name to reclaim
+		// Check for an existing beacon with the same name to reclaim.
+		// Status='Offline' is the original reconnect-after-disconnect case.
+		// Status='Online' is the post-enable refreshRegistration case
+		// (SDK pushed updated capabilities without disconnecting first).
+		// Either way, same name → same beacon — update in place rather
+		// than creating a duplicate record (which would orphan the
+		// FleetStore installation rows keyed on the old BeaconID and
+		// confuse the dispatch filter).
 		let tmpExistingBeacon = this.findBeaconByName(tmpName);
-		if (tmpExistingBeacon && tmpExistingBeacon.Status === 'Offline')
+		if (tmpExistingBeacon
+			&& (tmpExistingBeacon.Status === 'Offline'
+				|| tmpExistingBeacon.Status === 'Online'
+				|| tmpExistingBeacon.Status === 'Busy'))
 		{
 			tmpExistingBeacon.SessionID = pSessionID || null;
 			tmpExistingBeacon.LastHeartbeat = new Date().toISOString();
@@ -303,6 +369,12 @@ class UltravisorBeaconCoordinator extends libPictService
 				tmpReachability.onBeaconRegistered(tmpExistingBeacon.BeaconID);
 			}
 
+			// Bootstrap-flush: a reconnect is exactly the case we care
+			// about — the beacon was offline, local writes accumulated,
+			// now the beacon is back. Fire the same notification path
+			// as a fresh register so the bridges sweep their backlog.
+			this._notifyPersistenceBridgesOnConnect(tmpExistingBeacon.BeaconID);
+
 			return tmpExistingBeacon;
 		}
 
@@ -352,9 +424,81 @@ class UltravisorBeaconCoordinator extends libPictService
 			tmpReachability.onBeaconRegistered(tmpBeaconID);
 		}
 
+		// Notify the fleet manager so it can:
+		//   - auto-push any registered runtimes whose AutoPushOnConnect
+		//     is true and whose hash on the worker is stale
+		//   - auto-discover models the worker reports via LWM_Inventory
+		//     and import them into the fleet table at Source='discovered',
+		//     EnabledForDispatch=true (so existing dispatches keep working
+		//     without operator intervention)
+		//
+		// Critical: defer to the next tick. The WebSocket upgrade handler
+		// (which sets `_WorkItemPushHandler`) runs in the SAME tick as
+		// `/Beacon/Register`. If we kick off LWM_Inventory or runtime
+		// pushes synchronously here, those work items get pre-assigned
+		// (via the fleet-push affinity) BUT the WS handler isn't wired
+		// yet, so they never deliver — they just fill the beacon's
+		// CurrentWorkItems slot and starve every subsequent dispatch.
+		// setImmediate buys us "after the WS upgrade settles" without
+		// adding a real timer.
+		let tmpFleet = this._getService('UltravisorFleetManager');
+		if (tmpFleet && typeof tmpFleet.onBeaconConnected === 'function')
+		{
+			setImmediate(() =>
+			{
+				try { tmpFleet.onBeaconConnected(tmpBeaconID); }
+				catch (pErr)
+				{
+					this.log.warn(
+						`BeaconCoordinator: FleetManager.onBeaconConnected threw: ${pErr.message}`);
+				}
+			});
+		}
+
+		// Bootstrap-flush: notify persistence bridges that a beacon
+		// just connected so they can flush locally-buffered writes the
+		// beacon doesn't have. Each bridge inspects whether the new
+		// beacon supplies its capability (QueuePersistence /
+		// ManifestStore) and fires a sweep when relevant. setImmediate
+		// for the same reason as the FleetManager hook above — the
+		// WebSocket upgrade hasn't fully wired the push channel yet.
+		this._notifyPersistenceBridgesOnConnect(tmpBeaconID);
+
 		return tmpBeacon;
 	}
 
+	/**
+	 * Notify both persistence bridges that a beacon just connected.
+	 * Each bridge filters by capability internally so this is safe to
+	 * call for every beacon registration. Fire-and-forget; bridges
+	 * log their own success/failure. Wrapped in setImmediate so flush
+	 * dispatches don't preempt the WebSocket upgrade settlement.
+	 */
+	_notifyPersistenceBridgesOnConnect(pBeaconID)
+	{
+		let tmpQB = this._getService('UltravisorQueuePersistenceBridge');
+		let tmpMB = this._getService('UltravisorManifestStoreBridge');
+		setImmediate(() =>
+		{
+			if (tmpQB && typeof tmpQB.onBeaconConnected === 'function')
+			{
+				try { tmpQB.onBeaconConnected(pBeaconID); }
+				catch (pErr)
+				{
+					this.log.warn(`BeaconCoordinator: QueuePersistenceBridge.onBeaconConnected threw: ${pErr.message}`);
+				}
+			}
+			if (tmpMB && typeof tmpMB.onBeaconConnected === 'function')
+			{
+				try { tmpMB.onBeaconConnected(pBeaconID); }
+				catch (pErr)
+				{
+					this.log.warn(`BeaconCoordinator: ManifestStoreBridge.onBeaconConnected threw: ${pErr.message}`);
+				}
+			}
+		});
+	}
+
 	// ================================================================
 	// Action Catalog
 	// ================================================================
@@ -1071,31 +1215,27 @@ class UltravisorBeaconCoordinator extends libPictService
 			}
 		}
 
-		// Persist the full record to the SQLite-backed queue store so
-		// the /queue view + historical queries + cross-restart recovery
-		// have a canonical source of truth.
-		let tmpQueueStore = this._getQueueStore();
-		if (tmpQueueStore)
+		// Persist via the bridge (beacon when connected, in-process
+		// QueueStore otherwise). Skip QueuePersistence's own dispatches
+		// — recording them would create infinite recursion through the
+		// bridge → coordinator → bridge → ... loop.
+		let tmpBridge = this._getQueuePersistenceBridge();
+		if (tmpBridge && !this._isMetaCapability(tmpWorkItem.Capability))
 		{
-			try { tmpQueueStore.upsertWorkItem(tmpWorkItem); }
-			catch (pStoreErr) { this.log.warn(`BeaconCoordinator: queue store upsert failed: ${pStoreErr.message}`); }
-			try
-			{
-				tmpQueueStore.appendEvent({
-					WorkItemHash: tmpWorkItem.WorkItemHash,
-					RunID: tmpWorkItem.RunID,
-					EventType: 'enqueued',
-					FromStatus: '',
-					ToStatus: tmpWorkItem.Status,
-					Payload: {
-						Capability: tmpWorkItem.Capability,
-						Action: tmpWorkItem.Action,
-						Priority: tmpWorkItem.Priority,
-						AffinityKey: tmpWorkItem.AffinityKey
-					}
-				});
-			}
-			catch (pStoreErr2) { /* best effort */ }
+			this._persistBest(tmpBridge.upsertWorkItem(tmpWorkItem), 'queue upsert');
+			this._persistBest(tmpBridge.appendEvent({
+				WorkItemHash: tmpWorkItem.WorkItemHash,
+				RunID: tmpWorkItem.RunID,
+				EventType: 'enqueued',
+				FromStatus: '',
+				ToStatus: tmpWorkItem.Status,
+				Payload: {
+					Capability: tmpWorkItem.Capability,
+					Action: tmpWorkItem.Action,
+					Priority: tmpWorkItem.Priority,
+					AffinityKey: tmpWorkItem.AffinityKey
+				}
+			}), 'queue enqueued event');
 		}
 
 		// Broadcast the enqueue event.  Scheduler owns the ws envelope.
@@ -1171,6 +1311,31 @@ class UltravisorBeaconCoordinator extends libPictService
 				continue;
 			}
 
+			// Fleet-manager dispatch filter (same logic as pollForWork's
+			// pending-pass). System actions / unknown-model dispatches
+			// fall through; per-(beacon, model) gating only applies when
+			// the work item targets a known-installed model.
+			let tmpFleetWS = this._getService('UltravisorFleetManager');
+			if (tmpFleetWS && typeof tmpFleetWS.checkDispatchAllowed === 'function')
+			{
+				let tmpAllowWS;
+				try { tmpAllowWS = tmpFleetWS.checkDispatchAllowed(tmpBeacon.BeaconID, pWorkItem); }
+				catch (pErr)
+				{
+					this.log.warn(
+						`BeaconCoordinator: WS-push fleet filter threw: ${pErr.message} — allowing`);
+					tmpAllowWS = { Allowed: true };
+				}
+				if (tmpAllowWS && tmpAllowWS.Allowed === false)
+				{
+					this.log.info(
+						`BeaconCoordinator: WS-push fleet filter denied beacon [${tmpBeacon.BeaconID}] `
+						+ `for [${pWorkItem.Capability}/${pWorkItem.Action}] `
+						+ `(model=${tmpAllowWS.MatchedModelKey}, reason=${tmpAllowWS.Reason}).`);
+					continue;
+				}
+			}
+
 			// Assign the work item to this beacon
 			pWorkItem.Status = 'Running';
 			pWorkItem.AssignedBeaconID = tmpBeacon.BeaconID;
@@ -1282,37 +1447,35 @@ class UltravisorBeaconCoordinator extends libPictService
 					if (!isNaN(tmpEnqMs)) tmpWorkItem.QueueWaitMs = Math.max(0, Date.now() - tmpEnqMs);
 				}
 				tmpWorkItem.AttemptNumber = (tmpWorkItem.AttemptNumber || 0) + 1;
-				let tmpPollStoreA = this._getQueueStore();
-				if (tmpPollStoreA)
+				// Affinity-poll dispatch path. Bridge handles beacon-or-local
+				// routing; meta-capability skip mirrors the other write sites.
+				let tmpPollBridgeA = this._getQueuePersistenceBridge();
+				if (tmpPollBridgeA && !this._isMetaCapability(tmpWorkItem.Capability))
 				{
-					try
-					{
-						tmpPollStoreA.updateWorkItem(tmpWorkItem.WorkItemHash, {
-							Status: 'Running',
-							StartedAt: tmpWorkItem.StartedAt,
-							DispatchedAt: tmpWorkItem.DispatchedAt,
-							LastEventAt: tmpPollNowIso,
-							QueueWaitMs: tmpWorkItem.QueueWaitMs || 0,
-							AttemptNumber: tmpWorkItem.AttemptNumber
-						});
-						tmpPollStoreA.appendEvent({
-							WorkItemHash: tmpWorkItem.WorkItemHash,
-							RunID: tmpWorkItem.RunID,
-							EventType: 'dispatched',
-							FromStatus: 'Assigned',
-							ToStatus: 'Running',
-							BeaconID: pBeaconID,
-							Payload: { QueueWaitMs: tmpWorkItem.QueueWaitMs || 0, Path: 'poll' }
-						});
-						tmpPollStoreA.insertAttempt({
-							WorkItemHash: tmpWorkItem.WorkItemHash,
-							AttemptNumber: tmpWorkItem.AttemptNumber,
-							BeaconID: pBeaconID,
-							DispatchedAt: tmpWorkItem.DispatchedAt,
-							Outcome: 'Dispatched'
-						});
-					}
-					catch (pErr) { /* best effort */ }
+					this._persistBest(tmpPollBridgeA.updateWorkItem(tmpWorkItem.WorkItemHash, {
+						Status: 'Running',
+						StartedAt: tmpWorkItem.StartedAt,
+						DispatchedAt: tmpWorkItem.DispatchedAt,
+						LastEventAt: tmpPollNowIso,
+						QueueWaitMs: tmpWorkItem.QueueWaitMs || 0,
+						AttemptNumber: tmpWorkItem.AttemptNumber
+					}), 'queue dispatch update (affinity)');
+					this._persistBest(tmpPollBridgeA.appendEvent({
+						WorkItemHash: tmpWorkItem.WorkItemHash,
+						RunID: tmpWorkItem.RunID,
+						EventType: 'dispatched',
+						FromStatus: 'Assigned',
+						ToStatus: 'Running',
+						BeaconID: pBeaconID,
+						Payload: { QueueWaitMs: tmpWorkItem.QueueWaitMs || 0, Path: 'poll' }
+					}), 'queue dispatched event (affinity)');
+					this._persistBest(tmpPollBridgeA.insertAttempt({
+						WorkItemHash: tmpWorkItem.WorkItemHash,
+						AttemptNumber: tmpWorkItem.AttemptNumber,
+						BeaconID: pBeaconID,
+						DispatchedAt: tmpWorkItem.DispatchedAt,
+						Outcome: 'Dispatched'
+					}), 'queue insert attempt (affinity)');
 				}
 				this.log.info(`BeaconCoordinator: beacon [${pBeaconID}] picked up affinity-assigned work item [${tmpWorkItem.WorkItemHash}].`);
 				return this._sanitizeWorkItemForBeacon(tmpWorkItem);
@@ -1341,6 +1504,35 @@ class UltravisorBeaconCoordinator extends libPictService
 				continue;
 			}
 
+			// Fleet-manager dispatch filter: gate on per-(beacon, model)
+			// EnabledForDispatch state when the work item targets a
+			// known-installed model. System actions (LabsWorkerManagement,
+			// VideoPipeline/VP_EncodeVideo, etc.) and dispatches with no
+			// extractable model key fall through unchanged. See
+			// FleetManager.checkDispatchAllowed() for policy.
+			let tmpFleetForFilter = this._getService('UltravisorFleetManager');
+			if (tmpFleetForFilter && typeof tmpFleetForFilter.checkDispatchAllowed === 'function')
+			{
+				let tmpAllow;
+				try { tmpAllow = tmpFleetForFilter.checkDispatchAllowed(pBeaconID, tmpWorkItem); }
+				catch (pErr)
+				{
+					this.log.warn(
+						`BeaconCoordinator: fleet filter threw on `
+						+ `[${tmpWorkItem.WorkItemHash}]: ${pErr.message} — allowing`);
+					tmpAllow = { Allowed: true };
+				}
+				if (tmpAllow && tmpAllow.Allowed === false)
+				{
+					this.log.info(
+						`BeaconCoordinator: fleet filter denied beacon [${pBeaconID}] `
+						+ `for [${tmpWorkItem.Capability}/${tmpWorkItem.Action}] `
+						+ `(model=${tmpAllow.MatchedModelKey}, reason=${tmpAllow.Reason}) — `
+						+ `keeping work item pending for an enabled beacon.`);
+					continue;
+				}
+			}
+
 			// Claim this work item
 			let tmpPollClaimIso = new Date().toISOString();
 			let tmpPollFromStatus = tmpWorkItem.Status;
@@ -1357,39 +1549,38 @@ class UltravisorBeaconCoordinator extends libPictService
 				if (!isNaN(tmpEnqMs2)) tmpWorkItem.QueueWaitMs = Math.max(0, Date.now() - tmpEnqMs2);
 			}
 			tmpWorkItem.AttemptNumber = (tmpWorkItem.AttemptNumber || 0) + 1;
-			let tmpPollStoreB = this._getQueueStore();
-			if (tmpPollStoreB)
-			{
-				try
-				{
-					tmpPollStoreB.updateWorkItem(tmpWorkItem.WorkItemHash, {
-						Status: 'Running',
-						AssignedBeaconID: pBeaconID,
-						AssignedAt: tmpWorkItem.AssignedAt,
-						DispatchedAt: tmpWorkItem.DispatchedAt,
-						StartedAt: tmpWorkItem.StartedAt,
-						LastEventAt: tmpPollClaimIso,
-						QueueWaitMs: tmpWorkItem.QueueWaitMs || 0,
-						AttemptNumber: tmpWorkItem.AttemptNumber
-					});
-					tmpPollStoreB.appendEvent({
-						WorkItemHash: tmpWorkItem.WorkItemHash,
-						RunID: tmpWorkItem.RunID,
-						EventType: 'dispatched',
-						FromStatus: tmpPollFromStatus,
-						ToStatus: 'Running',
-						BeaconID: pBeaconID,
-						Payload: { QueueWaitMs: tmpWorkItem.QueueWaitMs || 0, Path: 'poll' }
-					});
-					tmpPollStoreB.insertAttempt({
-						WorkItemHash: tmpWorkItem.WorkItemHash,
-						AttemptNumber: tmpWorkItem.AttemptNumber,
-						BeaconID: pBeaconID,
-						DispatchedAt: tmpWorkItem.DispatchedAt,
-						Outcome: 'Dispatched'
-					});
-				}
-				catch (pErr) { /* best effort */ }
+			// Free-pool poll dispatch path. Same bridge + meta-capability
+			// guard as the affinity poll above; the only difference is
+			// the FromStatus carried into the event row.
+			let tmpPollBridgeB = this._getQueuePersistenceBridge();
+			if (tmpPollBridgeB && !this._isMetaCapability(tmpWorkItem.Capability))
+			{
+				this._persistBest(tmpPollBridgeB.updateWorkItem(tmpWorkItem.WorkItemHash, {
+					Status: 'Running',
+					AssignedBeaconID: pBeaconID,
+					AssignedAt: tmpWorkItem.AssignedAt,
+					DispatchedAt: tmpWorkItem.DispatchedAt,
+					StartedAt: tmpWorkItem.StartedAt,
+					LastEventAt: tmpPollClaimIso,
+					QueueWaitMs: tmpWorkItem.QueueWaitMs || 0,
+					AttemptNumber: tmpWorkItem.AttemptNumber
+				}), 'queue dispatch update (poll)');
+				this._persistBest(tmpPollBridgeB.appendEvent({
+					WorkItemHash: tmpWorkItem.WorkItemHash,
+					RunID: tmpWorkItem.RunID,
+					EventType: 'dispatched',
+					FromStatus: tmpPollFromStatus,
+					ToStatus: 'Running',
+					BeaconID: pBeaconID,
+					Payload: { QueueWaitMs: tmpWorkItem.QueueWaitMs || 0, Path: 'poll' }
+				}), 'queue dispatched event (poll)');
+				this._persistBest(tmpPollBridgeB.insertAttempt({
+					WorkItemHash: tmpWorkItem.WorkItemHash,
+					AttemptNumber: tmpWorkItem.AttemptNumber,
+					BeaconID: pBeaconID,
+					DispatchedAt: tmpWorkItem.DispatchedAt,
+					Outcome: 'Dispatched'
+				}), 'queue insert attempt (poll)');
 			}
 
 			if (tmpBeacon.CurrentWorkItems.indexOf(tmpWorkItem.WorkItemHash) === -1)
@@ -1580,34 +1771,33 @@ class UltravisorBeaconCoordinator extends libPictService
 			tmpJournal.appendEntry('complete', { WorkItemHash: pWorkItemHash });
 		}
 
-		// Persist to the new queue store + append event + update attempt.
-		let tmpQueueStore = this._getQueueStore();
-		if (tmpQueueStore)
-		{
-			try
-			{
-				tmpQueueStore.updateWorkItem(pWorkItemHash, {
-					Status: 'Complete',
-					CompletedAt: tmpWorkItem.CompletedAt,
-					LastEventAt: tmpWorkItem.LastEventAt,
-					Result: pResult || null
-				});
-				tmpQueueStore.appendEvent({
-					WorkItemHash: pWorkItemHash,
-					RunID: tmpWorkItem.RunID,
-					EventType: 'completed',
-					FromStatus: tmpFromStatus,
-					ToStatus: 'Complete',
-					BeaconID: tmpWorkItem.AssignedBeaconID,
-					Payload: { DurationMs: tmpDurationMs }
-				});
-				tmpQueueStore.updateAttemptOutcome(pWorkItemHash, tmpWorkItem.AttemptNumber || 1, {
+		// Persist via the bridge — beacon-backed when connected,
+		// in-process QueueStore otherwise. Skip meta-capability
+		// dispatches to avoid the QP_*-on-QP_* recursion.
+		let tmpCompleteBridge = this._getQueuePersistenceBridge();
+		if (tmpCompleteBridge && !this._isMetaCapability(tmpWorkItem.Capability))
+		{
+			this._persistBest(tmpCompleteBridge.updateWorkItem(pWorkItemHash, {
+				Status: 'Complete',
+				CompletedAt: tmpWorkItem.CompletedAt,
+				LastEventAt: tmpWorkItem.LastEventAt,
+				Result: pResult || null
+			}), 'queue complete update');
+			this._persistBest(tmpCompleteBridge.appendEvent({
+				WorkItemHash: pWorkItemHash,
+				RunID: tmpWorkItem.RunID,
+				EventType: 'completed',
+				FromStatus: tmpFromStatus,
+				ToStatus: 'Complete',
+				BeaconID: tmpWorkItem.AssignedBeaconID,
+				Payload: { DurationMs: tmpDurationMs }
+			}), 'queue completed event');
+			this._persistBest(tmpCompleteBridge.updateAttemptOutcome(
+				pWorkItemHash, tmpWorkItem.AttemptNumber || 1, {
 					CompletedAt: tmpWorkItem.CompletedAt,
 					Outcome: 'Complete',
 					DurationMs: tmpDurationMs
-				});
-			}
-			catch (pStoreErr) { /* best effort */ }
+				}), 'queue attempt outcome');
 		}
 
 		let tmpScheduler = this._getScheduler();
@@ -1777,36 +1967,35 @@ class UltravisorBeaconCoordinator extends libPictService
 			tmpJournal.appendEntry('fail', { WorkItemHash: pWorkItemHash });
 		}
 
-		// Persist to the new queue store + event + attempt outcome.
-		let tmpFailStore = this._getQueueStore();
-		if (tmpFailStore)
-		{
-			try
-			{
-				tmpFailStore.updateWorkItem(pWorkItemHash, {
-					Status: 'Error',
-					CompletedAt: tmpWorkItem.CompletedAt,
-					LastEventAt: tmpWorkItem.LastEventAt,
-					LastError: tmpWorkItem.LastError,
-					Result: tmpWorkItem.Result
-				});
-				tmpFailStore.appendEvent({
-					WorkItemHash: pWorkItemHash,
-					RunID: tmpWorkItem.RunID,
-					EventType: 'failed',
-					FromStatus: tmpFromStatus,
-					ToStatus: 'Error',
-					BeaconID: tmpWorkItem.AssignedBeaconID,
-					Payload: { Error: tmpWorkItem.LastError, DurationMs: tmpFailDurationMs }
-				});
-				tmpFailStore.updateAttemptOutcome(pWorkItemHash, tmpWorkItem.AttemptNumber || 1, {
+		// Persist via the bridge — beacon-backed when connected,
+		// in-process QueueStore otherwise. Skip meta-capability
+		// dispatches to avoid recursion.
+		let tmpFailBridge = this._getQueuePersistenceBridge();
+		if (tmpFailBridge && !this._isMetaCapability(tmpWorkItem.Capability))
+		{
+			this._persistBest(tmpFailBridge.updateWorkItem(pWorkItemHash, {
+				Status: 'Error',
+				CompletedAt: tmpWorkItem.CompletedAt,
+				LastEventAt: tmpWorkItem.LastEventAt,
+				LastError: tmpWorkItem.LastError,
+				Result: tmpWorkItem.Result
+			}), 'queue fail update');
+			this._persistBest(tmpFailBridge.appendEvent({
+				WorkItemHash: pWorkItemHash,
+				RunID: tmpWorkItem.RunID,
+				EventType: 'failed',
+				FromStatus: tmpFromStatus,
+				ToStatus: 'Error',
+				BeaconID: tmpWorkItem.AssignedBeaconID,
+				Payload: { Error: tmpWorkItem.LastError, DurationMs: tmpFailDurationMs }
+			}), 'queue failed event');
+			this._persistBest(tmpFailBridge.updateAttemptOutcome(
+				pWorkItemHash, tmpWorkItem.AttemptNumber || 1, {
 					CompletedAt: tmpWorkItem.CompletedAt,
 					Outcome: 'Error',
 					ErrorMessage: tmpWorkItem.LastError,
 					DurationMs: tmpFailDurationMs
-				});
-			}
-			catch (pStoreErr) { /* best effort */ }
+				}), 'queue fail attempt outcome');
 		}
 
 		let tmpFailScheduler = this._getScheduler();
@@ -2168,17 +2357,16 @@ class UltravisorBeaconCoordinator extends libPictService
 		// Mark the item as freshly heard-from for health scoring.
 		tmpWorkItem.LastEventAt = tmpWorkItem.Progress.UpdatedAt;
 		if (!tmpWorkItem.StartedAt) tmpWorkItem.StartedAt = tmpWorkItem.Progress.UpdatedAt;
-		let tmpProgressStore = this._getQueueStore();
-		if (tmpProgressStore)
-		{
-			try
-			{
-				tmpProgressStore.updateWorkItem(pWorkItemHash, {
-					LastEventAt: tmpWorkItem.LastEventAt,
-					StartedAt: tmpWorkItem.StartedAt
-				});
-			}
-			catch (pErr) { /* best effort */ }
+		// Progress updates also land via the bridge so a beacon-backed
+		// persistence backend sees the same heartbeat trail an in-process
+		// store would. Skip meta-capabilities to avoid recursion.
+		let tmpProgressBridge = this._getQueuePersistenceBridge();
+		if (tmpProgressBridge && !this._isMetaCapability(tmpWorkItem.Capability))
+		{
+			this._persistBest(tmpProgressBridge.updateWorkItem(pWorkItemHash, {
+				LastEventAt: tmpWorkItem.LastEventAt,
+				StartedAt: tmpWorkItem.StartedAt
+			}), 'queue progress update');
 		}
 
 		// Accumulate log entries